From 75426a3479373b4710ab6ebf886ad455ded8215f Mon Sep 17 00:00:00 2001 From: numbbbbb Date: Thu, 12 Jun 2014 07:39:58 +0800 Subject: [PATCH] ver 1.0 --- change_cdn.py | 2 + chapter1/01_swift.html | 36 +- chapter1/02_a_swift_tour.html | 116 ++- chapter1/chapter1.html | 22 +- chapter2/01_The_Basics.html | 317 +++--- chapter2/02_Basic_Operators.html | 225 +++-- chapter2/03_Strings_and_Characters.html | 203 ++-- chapter2/04_Collection_Types.html | 108 +- chapter2/05_Control_Flow.html | 432 ++++---- chapter2/06_Functions.html | 189 ++-- chapter2/07_Closures.html | 137 ++- chapter2/08_Enumerations.html | 90 +- chapter2/09_Classes_and_Structures.html | 111 +- chapter2/10_Properties.html | 175 ++-- chapter2/11_Methods.html | 145 +-- chapter2/12_Subscripts.html | 106 +- chapter2/13_Inheritance.html | 124 ++- chapter2/14_Initialization.html | 453 ++++++++- chapter2/15_Deinitialization.html | 147 +-- chapter2/16_Automatic_Reference_Counting.html | 253 ++--- chapter2/17_Optional_Chaining.html | 124 ++- chapter2/18_Type_Casting.html | 182 ++-- chapter2/19_Nested_Types.html | 34 +- chapter2/20_Extensions.html | 329 +++--- chapter2/21_Protocols.html | 300 +++--- chapter2/22_Generics.html | 419 ++++---- chapter2/23_Advanced_Operators.html | 216 +--- chapter2/chapter2.html | 22 +- chapter3/01_About_the_Language_Reference.html | 38 +- chapter3/02_Lexical_Structure.html | 49 +- chapter3/03_Types.html | 89 +- chapter3/04_Expressions.html | 318 +++--- chapter3/05_Declarations.html | 681 ++++++++++++- chapter3/06_Attributes.html | 35 +- chapter3/07_Patterns.html | 45 +- .../08_Generic_Parameters_and_Arguments.html | 28 +- chapter3/09_Summary_of_the_Grammar.html | 603 ++++++++--- chapter3/10_Statements.html | 42 +- chapter3/chapter3.html | 20 +- gitbook/jsrepl/sandbox.html | 13 +- index.html | 84 +- manifest.appcache | 6 +- search_index.json | 2 +- source/README.md | 65 +- source/SUMMARY.md | 2 +- source/chapter1/01_swift.md | 12 +- source/chapter1/02_a_swift_tour.md | 108 +- source/chapter2/01_The_Basics.md | 288 +++--- source/chapter2/02_Basic_Operators.md | 208 ++-- source/chapter2/03_Strings_and_Characters.md | 206 ++-- source/chapter2/04_Collection_Types.md | 78 +- source/chapter2/05_Control_Flow.md | 527 +++++----- source/chapter2/06_Functions.md | 138 +-- source/chapter2/07_Closures.md | 112 ++- source/chapter2/08_Enumerations.md | 69 +- source/chapter2/09_Classes_and_Structures.md | 191 ++-- source/chapter2/10_Properties.md | 180 ++-- source/chapter2/11_Methods.md | 119 ++- source/chapter2/12_Subscripts.md | 80 +- source/chapter2/13_Inheritance.md | 109 +- source/chapter2/14_Initialization.md | 601 +++++++++++ source/chapter2/15_Deinitialization.md | 129 +-- .../16_Automatic_Reference_Counting.md | 292 +++--- source/chapter2/17_Optional_Chaining.md | 96 +- source/chapter2/18_Type_Casting.md | 175 ++-- source/chapter2/19_Nested_Types.md | 12 +- source/chapter2/20_Extensions.md | 183 ++-- source/chapter2/21_Protocols.md | 283 +++--- source/chapter2/22_Generics.md | 533 +++++----- source/chapter2/23_Advanced_Operators.md | 227 +---- .../01_About_the_Language_Reference.md | 18 +- source/chapter3/02_Lexical_Structure.md | 171 ++-- source/chapter3/03_Types.md | 67 +- source/chapter3/04_Expressions.md | 292 +++--- source/chapter3/05_Declarations.md | 902 +++++++++++++++++ source/chapter3/06_Attributes.md | 11 + source/chapter3/07_Patterns.md | 65 +- .../08_Generic_Parameters_and_Arguments.md | 4 + source/chapter3/09_Summary_of_the_Grammar.md | 944 +++++++++--------- source/chapter3/10_Statements.md | 27 +- 80 files changed, 9089 insertions(+), 5505 deletions(-) diff --git a/change_cdn.py b/change_cdn.py index 312074b9..9842e4c7 100644 --- a/change_cdn.py +++ b/change_cdn.py @@ -1,4 +1,5 @@ #!/usr/bin/python +# coding:utf-8 import os @@ -14,6 +15,7 @@ def iter(path): insert_pos = content.find("", content.find("Generated using GitBook")) + 6 content = content[:insert_pos] + '''
    • ''' + content[insert_pos:] + content.replace(r'.*?', "《The Swift Programming Language》完整中文版") with open(root + '/' + fn, 'w') as f: f.write(content) diff --git a/chapter1/01_swift.html b/chapter1/01_swift.html index 42d8815f..90d6f90a 100644 --- a/chapter1/01_swift.html +++ b/chapter1/01_swift.html @@ -5,12 +5,12 @@ - 关于 Swift | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,15 +587,19 @@
    -
    +
    -

    关于 Swift

    +
    +

    翻译：numbbbbb

    +

    校对：yeahdongcn

    +
    +

    关于 Swift

    -

    Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受C的兼容性的限制。Swift 使用安全的编程模式并添加了很多新特性，这将使编程更简单，扩展性更强，也更有趣。除此之外，Swift 还支持人见人爱的 Cocoa 和 Cocoa Touch 框架。拥有了这些特性，Swift将重新定义软件开发。

    -

    Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。得益于这些基础工作，我们现在可以发布一个新语言，用于未来的苹果软件的开发。

    -

    Objective-C 开发者对于 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。

    +

    Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受C兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。Swift 是基于成熟而且倍受喜爱得 Cocoa 和 Cocoa Touch 框架，他的降临将重新定义软件开发。

    +

    Swift 的开发从很久之前就开始了。为了给 Swift 打好基础，苹果公司改进了编译器，调试器和框架结构。我们使用自动引用计数（Automatic Reference Counting, ARC）来简化内存管理。我们在 Foundation 和 Cocoa的基础上构建框架栈并将其标准化。Objective-C 本身支持块、集合语法和模块，所以框架可以轻松支持现代编程语言技术。正是得益于这些基础工作，我们现在才能发布这样一个用于未来苹果软件开发的新语言。

    +

    Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。

    Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。

    -

    Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 即可以用于开发“hello, world”这样的小程序，也可以用于开发一个完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。

    +

    Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 即可以用于开发“hello, world”这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。

    用 Swift 编写 iOS 和 OS X 应用将是一场美妙的体验，Swift 之后也会不断开发新特性和兼容性。我们对 Swift 充满信心，你还在等什么！

    @@ -642,6 +646,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter1/02_a_swift_tour.html b/chapter1/02_a_swift_tour.html index 1460cda7..56de722e 100644 --- a/chapter1/02_a_swift_tour.html +++ b/chapter1/02_a_swift_tour.html @@ -5,12 +5,12 @@ - Swift 初见 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,29 +587,35 @@
    -
    +
    -

    Swift 初见

    +
    +

    翻译：numbbbbb +校对：shinyzhu

    +
    +

    Swift 初见

    本页内容包括：

    通常来说，编程语言教程中的第一个程序应该在屏幕上打印“Hello, world”。在 Swift 中，可以用一行代码实现：

    println("Hello, world")

    如果你写过 C 或者 Objective-C 代码，那你应该很熟悉这种形式——在 Swift 中，这行代码就是一个完整的程序。你不需要为了输入输出或者字符串处理导入一个单独的库。全局作用域中的代码会被自动当做程序的入口点，所以你也不需要main函数。你同样不需要在每个语句结尾写上分号。

    这个教程会通过一系列编程例子来让你对 Swift 有初步了解，如果你有什么不理解的地方也不用担心——任何本章介绍的内容都会在后面的章节中详细讲解。

    -

    注意：为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。

    +

    注意：

    +

    为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。

    +

    简单值

    -

    使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要获取，但是你必须而且只能为它赋值一次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。

    +

    使用let来声明常量，使用var来声明变量。一个常量的值在编译时并不需要获取，但是你只能为它赋值一次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。

    var myVariable = 42
 myVariable = 50
 let myConstant = 42
@@ -619,14 +625,16 @@ let myConstant = 42
 let implicitDouble = 70.0
 let explicitDouble: Double = 70
    -

    练习：创建一个常量，显式指定类型为Float并指定初始值为4。

    +

    练习：

    +

    创建一个常量，显式指定类型为Float并指定初始值为4。

    值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。

    let label = "The width is"
 let width = 94
 let widthLabel = label + String(width)
    -

    练习：删除最后一行中的String，错误提示是什么？

    +

    练习：

    +

    删除最后一行中的String，错误提示是什么？

    有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。例如：

    let apples = 3
@@ -634,7 +642,8 @@ let oranges = 5
 let appleSummary = "I have \(apples) apples."
 let fruitSummary = "I have \(apples + oranges) pieces of fruit."
    -

    练习：使用\()来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。

    +

    练习：

    +

    使用\()来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。

    使用方括号[]来创建数组和字典，并使用下标或者键（key）来访问元素。

    var shoppingList = ["catfish", "water", "tulips", "blue paint"]
@@ -650,7 +659,8 @@ occupations["Jayne"] = "Public Relations"
 let emptyDictionary = Dictionary<String, Float>()

    如果类型信息可以被推断出来，你可以用[]和[:]来创建空数组和空字典——就像你声明变量或者给函数传参数的时候一样。

    shoppingList = []   // 去逛街并买点东西
-

    控制流

    +

    +

    控制流

    使用if和switch来进行条件操作，使用for-in、for、while和do-while来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。

    let individualScores = [75, 43, 103, 87, 12]
 var teamScore = 0
@@ -673,7 +683,8 @@ if let name = optionalName {
     greeting = "Hello, \(name)"
 }
    -

    练习：把optionalName改成nil，greeting会是什么？添加一个else语句，当optionalName是nil时给greeting赋一个不同的值。

    +

    练习：

    +

    把optionalName改成nil，greeting会是什么？添加一个else语句，当optionalName是nil时给greeting赋一个不同的值。

    如果变量的可选值是nil，条件会判断为false，大括号中的代码会被跳过。如果不是nil，会将值赋给let后面的常量，这样代码块中就可以使用这个值了。

    switch支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。

    @@ -689,7 +700,8 @@ default: let vegetableComment = "Everything tastes good in soup." }
    -

    练习：删除default语句，看看会有什么错误？

    +

    练习：

    +

    删除default语句，看看会有什么错误？

    运行switch中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句结尾写break。

    你可以使用for-in来遍历字典，需要两个变量来表示每个键值对。

    @@ -708,7 +720,8 @@ for (kind, numbers) in interestingNumbers { } largest
    -

    练习：添加另一个变量来记录哪种类型的数字是最大的。

    +

    练习：

    +

    添加另一个变量来记录哪种类型的数字是最大的。

    使用while来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。

    var n = 2
@@ -735,6 +748,7 @@ for var i = 0; i < 3; ++i {
 }
 secondForLoop

    使用..创建的范围不包含上界，如果想包含的话需要使用...。

    +

    函数和闭包

    使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值。

    func greet(name: String, day: String) -> String {
@@ -742,7 +756,8 @@ secondForLoop
 }
 greet("Bob", "Tuesday")
    -

    练习：删除day参数，添加一个参数来表示今天吃了什么午饭。

    +

    练习：

    +

    删除day参数，添加一个参数来表示今天吃了什么午饭。

    使用一个元组来返回多个值。

    func getGasPrices() -> (Double, Double, Double) {
@@ -760,7 +775,8 @@ getGasPrices()
 sumOf()
 sumOf(42, 597, 12)
    -

    练习：写一个计算参数平均值的函数。

    +

    练习：

    +

    写一个计算参数平均值的函数。

    函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

    func returnFifteen() -> Int {
@@ -795,19 +811,21 @@ func lessThanTen(number: Int) -> Bool {
 }
 var numbers = [20, 19, 7, 12]
 hasAnyMatches(numbers, lessThanTen)
-

    函数实际上是一种特殊的闭包，你可以使用{}来创建一个匿名闭包。使用in来分割参数、返回值与执行体。

    +

    函数实际上是一种特殊的闭包，你可以使用{}来创建一个匿名闭包。使用in来分割参数并返回类型。

    numbers.map({
     (number: Int) -> Int in
     let result = 3 * number
     return result
     })
    -

    练习：重写闭包，对所有奇数返回0.

    +

    练习：

    +

    重写闭包，对所有奇数返回 0.

    有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。

    你可以通过参数位置而不是参数名字来引用参数——这个方法在非常短的闭包中非常有用。当一个闭包作为最后一个参数传给一个函数的时候，它可以直接跟在括号后面。

    sort([1, 5, 3, 12, 2]) { $0 > $1 }
-

    对象和类

    +

    +

    对象和类

    使用class和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。

    class Shape {
     var numberOfSides = 0
@@ -816,7 +834,8 @@ hasAnyMatches(numbers, lessThanTen)
     }
 }
    -

    练习：使用let添加一个常量属性，再添加一个接收一个参数的方法。

    +

    练习：

    +

    使用let添加一个常量属性，再添加一个接收一个参数的方法。

    要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。

    var shape = Shape()
@@ -860,7 +879,8 @@ let test = Square(sideLength: 5.2, name: "my test square")
 test.area()
 test.simpleDescription()
    -

    练习：创建NamedShape的另一个子类Circle，构造器接收两个参数，一个是半径一个是名称，实现area和describe方法。

    +

    练习：

    +

    创建NamedShape的另一个子类Circle，构造器接收两个参数，一个是半径一个是名称，实现area和describe方法。

    属性可以有 getter 和 setter 。

    class EquilateralTriangle: NamedShape {
@@ -931,7 +951,8 @@ counter.incrementBy(2, numberOfTimes: 7)

    处理变量的可选值时，你可以在操作（比如方法、属性和子脚本）之前加?。如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil。否则，?之后的东西都会被运行。在这两种情况下，整个表达式的值也是一个可选值。

    let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
 let sideLength = optionalSquare?.sideLength
-

    枚举和结构体

    +

    +

    枚举和结构体

    使用enum来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。

    enum Rank: Int {
     case Ace = 1
@@ -955,7 +976,8 @@ let sideLength = optionalSquare?.sideLength
 let ace = Rank.Ace
 let aceRawValue = ace.toRaw()
    -

    练习：写一个函数，通过比较它们的原始值来比较两个Rank值。

    +

    练习：

    +

    写一个函数，通过比较它们的原始值来比较两个Rank值。

    在上面的例子中，枚举原始值的类型是Int，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。

    使用toRaw和fromRaw函数来在原始值和枚举值之间进行转换。

    @@ -982,7 +1004,8 @@ let aceRawValue = ace.toRaw() let hearts = Suit.Hearts 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来创建一个结构体。结构体和类有很多相同的地方，比如方法和构造器。它们之间最大的一个区别就是 @@ -998,7 +1021,8 @@ let heartsDescription = hearts.simpleDescription() let threeOfSpades = Card(rank: .Three, suit: .Spades) let threeOfSpadesDescription = threeOfSpades.simpleDescription()

    -

    练习：给Card添加一个方法，创建一副完整的扑克牌并把每张牌的rank和suit对应起来。

    +

    练习：

    +

    给Card添加一个方法，创建一副完整的扑克牌并把每张牌的 rank 和 suit 对应起来。

    一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置原始值。

    例如，考虑从服务器获取日出和日落的时间。服务器会返回正常结果或者错误信息。

    @@ -1017,9 +1041,11 @@ case let .Error(error): let serverResponse = "Failure... \(error)" }
    -

    练习：给ServerResponse和switch添加第三种情况。

    +

    练习：

    +

    给ServerResponse和switch添加第三种情况。

    注意如何从ServerResponse中提取日升和日落时间。

    +

    接口和扩展

    使用protocol来声明一个接口。

    protocol ExampleProtocol {
@@ -1048,7 +1074,8 @@ var b = SimpleStructure()
 b.adjust()
 let bDescription = b.simpleDescription
    -

    练习：写一个实现这个接口的枚举。

    +

    练习：

    +

    写一个实现这个接口的枚举。

    注意声明SimpleStructure时候mutating关键字用来标记一个会修改结构体的方法。SimpleClass的声明不需要标记任何方法因为类中的方法经常会修改类。

    使用extension来为现有的类型添加功能，比如添加一个计算属性的方法。你可以使用扩展来给任意类型添加协议，甚至是你从外部库或者框架中导入的类型。

    @@ -1062,13 +1089,15 @@ let bDescription = b.simpleDescription } 7.simpleDescription
    -

    练习：给Double类型写一个扩展，添加absoluteValue功能。

    +

    练习：

    +

    给Double类型写一个扩展，添加absoluteValue功能。

    你可以像使用其他命名类型一样使用接口名——例如，创建一个有不同类型但是都实现一个接口的对象集合。当你处理类型是接口的值时，接口外定义的方法不可用。

    let protocolValue: ExampleProtocol = a
 protocolValue.simpleDescription
 // protocolValue.anotherProperty  // Uncomment to see the error

    即使protocolValue变量运行时的类型是simpleClass，编译器会把它的类型当做ExampleProtocol。这表示你不能调用类在它实现的接口之外实现的方法或者属性。

    +

    泛型

    在尖括号里写一个名字来创建一个泛型函数或者类型。

    func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
@@ -1100,7 +1129,8 @@ possibleInteger = .Some(100)
 }
 anyCommonElements([1, 2, 3], [3])
    -

    练习：修改anyCommonElements函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。

    +

    练习：

    +

    修改anyCommonElements函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。

    简单起见，你可以忽略where，只在冒号后面写接口或者类名。<T: Equatable>和<T where T: Equatable>是等价的。

    @@ -1148,6 +1178,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter1/chapter1.html b/chapter1/chapter1.html index 1666ca3e..a4045b55 100644 --- a/chapter1/chapter1.html +++ b/chapter1/chapter1.html @@ -5,12 +5,12 @@ - 欢迎使用 Swift | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,7 +587,7 @@
    -
    +

    欢迎使用 Swift

    在本章中您将了解 Swift 的特性和开发历史，并对 Swift 有一个初步的了解。

    @@ -636,6 +636,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/01_The_Basics.html b/chapter2/01_The_Basics.html index 7f36811b..06a42f3b 100644 --- a/chapter2/01_The_Basics.html +++ b/chapter2/01_The_Basics.html @@ -5,12 +5,12 @@ - 基础部分 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,95 +587,122 @@
    -
    +
    -

    基础部分

    +
    +

    翻译：numbbbbb, lyuka, JaySurplus

    +

    校对：lslxdx

    +
    +

    基础部分

    +

    本页包含内容：

    +

    Swift 是 iOS 和 OS X 应用开发的一门新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。

    -

    Swift 的类型是在 C 和 Objective-C 的基础上提出的，Int是整型；Double和Float是浮点型；Bool是布尔型；String是字符串。Swift 还有两个有用的集合类型，Array和Dictionary，详情参见集合类型(待添加链接)。

    +

    Swift 的类型是在 C 和 Objective-C 的基础上提出的，Int是整型；Double和Float是浮点型；Bool是布尔型；String是字符串。Swift 还有两个有用的集合类型，Array和Dictionary，请参考集合类型。

    就像 C 语言一样，Swift 使用变量来进行存储并通过变量名来关联值。在 Swift 中，值不可变的变量有着广泛的应用，它们就是常量，而且比 C 语言的常量更强大。在 Swift 中，如果你要处理的值不需要改变，那使用常量可以让你的代码更加安全并且更好地表达你的意图。

    除了我们熟悉的类型，Swift 还增加了 Objective-C 中没有的类型比如元组（Tuple）。元组可以让你创建或者传递一组数据，比如作为函数的返回值时，你可以用一个元组可以返回多个值。

    Swift 还增加了可选（Optional）类型，用于处理值缺失的情况。可选表示“那儿有一个值，并且它等于 x ”或者“那儿没有值”。可选有点像在 Objective-C 中使用nil，但是它可以用在任何类型上，不仅仅是类。可选类型比 Objective-C 中的nil指针更加安全也更具表现力，它是 Swift 许多强大特性的重要组成部分。

    Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift 可以让你清楚地知道值的类型。如果你的代码期望得到一个String，类型安全会阻止你不小心传入一个Int。你可以在开发阶段尽早发现并修正错误。

    +

    常量和变量

    -

    常量和变量把一个名字（比如maximumNumberOfLoginAttempts或者welcomeMessage）和一个指定类型的值（比如数字10或者字符串Hello）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。

    +

    常量和变量把一个名字（比如maximumNumberOfLoginAttempts或者welcomeMessage）和一个指定类型的值（比如数字10或者字符串"Hello"）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。

    声明常量和变量

    常量和变量必须在使用前声明，用let来声明常量，用var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数：

    let maximumNumberOfLoginAttempts = 10
 var currentLoginAttempt = 0
-

    这两行代码可以被理解为 -： -“声明一个名字是maximumNumberOfLoginAttempts的新常量，并给它一个值10。然后，声明一个名字是currentLoginAttempt的变量并将它的值初始化为0.”

    +

    这两行代码可以被理解为：

    +

    “声明一个名字是maximumNumberOfLoginAttempts的新常量，并给它一个值10。然后，声明一个名字是currentLoginAttempt的变量并将它的值初始化为0.”

    在这个例子中，允许的最大尝试登录次数被声明为一个常量，因为这个值不会改变。当前尝试登录次数被声明为一个变量，因为每次尝试登录失败的时候都需要增加这个值。

    你可以在一行中声明多个常量或者多个变量，用逗号隔开：

    var x = 0.0, y = 0.0, z = 0.0
    -

    注意：如果你的代码中有不需要改变的值，请将它声明为常量。只将需要改变的值声明为变量。

    +

    注意：

    +

    如果你的代码中有不需要改变的值，请使用let关键字将它声明为常量。只将需要改变的值声明为变量。

    类型标注

    -

    当你声明常量或者变量的时候可以加上类型标注，说明常量或者变量中要存储的值的类型。如果要添加类型标注，在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。

    +

    当你声明常量或者变量的时候可以加上类型标注(type annotation)，说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。

    这个例子给welcomeMessage变量添加了类型标注，表示这个变量可以存储String类型的值：

    var welcomeMessage: String
-

    声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：：

    +

    声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：

    “声明一个类型为String，名字为welcomeMessage的变量。”

    “类型为String”的意思是“可以存储任意String类型的值。”

    welcomeMessage变量现在可以被设置成任意字符串：

    welcomeMessage = "Hello"
    -

    注意：一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，详情参见类型安全和类型推断(待添加链接)。在上面的例子中，没有给welcomeMessage赋初始值，所以添加了一个类型标注。

    +

    注意：

    +

    一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考类型安全和类型推断。在上面的例子中，没有给welcomeMessage赋初始值，所以变量welcomeMessage的类型是通过一个类型标注指定的，而不是通过初始值推断的。

    常量和变量的命名

    -

    你可以用任何你喜欢的字符作为常量和变量名，包括Unicode字符：

    +

    你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符：

    let π = 3.14159
 let 你好 = "你好世界"
 let 🐶🐮 = "dogcow"
-

    常量与变量名不能包含数学符号，箭头，保留的(或者非法的)Unicode码位，连线与制表符。尽管常量与变量名中可以包含数字，但是它们不能以数字打头。

    -

    一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者以改变其存储的值为其他类型。同时，你也不能将常量与变量进行互转。

    +

    常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。

    +

    一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。

    -

    注意：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号(`)将关键字围住的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。

    +

    注意：

    +

    如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。

    你可以更改现有的变量值为其他同类型的值，在下面的例子中，friendlyWelcome的值从"Hello!"改为了"Bonjour!":

    var friendlyWelcome = "Hello!"
 friendlyWelcome = "Bonjour!"
-// friendlyWelcome is now "Bonjour!"
-

    和变量不一样，常量的值一旦被确定以后就不能更改了。尝试这样做会在编译时报错：

    +// friendlyWelcome 现在是 "Bonjour!" +

    与变量不同，常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错：

    let languageName = "Swift"
 languageName = "Swift++"
-// this is a compile-time error - languageName cannot be changed
+// 这会报编译时错误 - languageName 不可改变

    输出常量和变量

    你可以用println函数来输出当前常量或变量的值:

    println(friendlyWelcome)
-// prints "Bonjour!"
-

    println是一个用来输出的全局函数，输出的内容会在最后带换行。如果你用Xcode，println将会输出内容到“console”面板上。(另一种函数叫print，唯一区别是在输出内容最后不会加入换行。)

    +// 输出 "Bonjour!" +

    println是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，println将会输出内容到“console”面板上。(另一种函数叫print，唯一区别是在输出内容最后不会换行。)

    println函数输出传入的String值：

    println("This is a string")
-// prints "This is a string"
-

    像Cocoa里的NSLog函数一样，println函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。

    -

    Swift用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift会用当前常量或变量的值替换这些占位符。将常量或变量名放入反斜杠符加一对圆括号中"\()"：

    +// 输出 "This is a string" +

    与 Cocoa 里的NSLog函数类似的是，println函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。

    +

    Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：

    println("The current value of friendlyWelcome is \(friendlyWelcome)")
-// prints "The current value of friendlyWelcome is Bonjour!
+// 输出 "The current value of friendlyWelcome is Bonjour!
    -

    注意：字符串插值所有可用的选项在 字符串插值 这章中讲述。

    +

    注意：

    +

    字符串插值所有可用的选项，请参考字符串插值。

    -

    注释

    +

    +

    注释

    请将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。

    -

    Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠作(//)为起始标记:

    -
    // this is a comment
-

    你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(/*)，终止标记为一个星号后跟随单个正斜杠(*/):

    -
    /* this is also a comment,
-but written over multiple lines */
-

    与C 语言多行注释不同的是，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：

    -
    /* this is the start of the first multiline comment
-/* this is the second, nested multiline comment */
-this is the end of the first multiline comment */
+
    Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠作(//)为起始标记:
    
+
    // 这是一个注释
+
    你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(/*)，终止标记为一个星号后跟随单个正斜杠(*/):
    
+
    /* 这是一个,
+多行注释 */
+
    与C 语言多行注释不同，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：
    
+
    /* 这是第一个多行注释的开头
+/* 这是第二个被嵌套的多行注释 */
+这是第一个多行注释的结尾 */
 
    通过运用嵌套多行注释，你可以快速方便的注释掉一大段代码，即使这段代码之中已经含有了多行注释块。
    
+
    
 
    分号
    
-
    与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号(;)，当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句:
    
+
    与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（;），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句：
    
 
    let cat = "🐱"; println(cat)
-// prints "🐱"
-
    整数
    
-
    整数就是没有小数部分的数字，比如42和-23。整数可以是有符号（正、负、零）或者无符号（正、零）。
    
-
    Swift 提供了8、16、32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。
    
+// 输出 "🐱"
+

    +

    整数

    +

    整数就是没有小数部分的数字，比如42和-23。整数可以是有符号（正、负、零）或者无符号（正、零）。

    +

    Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。

    整数范围

    你可以访问不同整数类型的min和max属性来获取对应类型的最大值和最小值：

    let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型的最小值
@@ -694,8 +721,10 @@ let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型的最大值
 
  • 在64位平台上，UInt和UInt64长度相同。
    • 
 
 
    
-
    注意：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，详情参见类型安全和类型推测。
    
+
    注意：
    
+
    尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，请参考类型安全和类型推测。
    
 
    
+
    
 
    浮点数
    
 
    浮点数是有小数部分的数字，比如3.14159，0.1和-273.15。
    
 
    浮点类型比整数类型表示的范围更大，可以存储比Int类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
    
@@ -704,73 +733,77 @@ let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型的最大值
 
  • Float表示32位浮点数。精度要求不高的话可以使用此类型。
    • 
 
 
    
-
    注意：Double精确度很高，至少有15位数字，而Float最少只有6位数字。选择哪个类型取决于你的代码需要处理的数字大小。
    
+
    注意：
    
+
    Double精确度很高，至少有15位数字，而Float最少只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围。
    
 
    
+
    
 
    类型安全和类型推测
    
-
    Swift 是一个类型安全的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能不小心传进去一个Int。
    
-
    Swift 是类型安全的，会在编译你的代码时进行类型检查，如果遇到不匹配的类型会报错。这可以让你在开发的时候尽早发现并修复错误。
    
-
    当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，判断你赋的值即可。
    
-
    因为有类型推测，和 C 或者 Objc 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
    
-
    当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个原始值即可触发类型推测。（原始值就是会直接出现在你代码中的值，比如42和3.14159。）
    
-
    举个例子，如果你给一个新常量赋值42并且没有标明类型，Swift 可以推测出常量类型是Int，因为你给它赋的初值看起来很像一个整数：
    
+
    Swift 是一个类型安全(type safe )的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能不小心传进去一个Int。
    
+
    由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查(type checks)，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
    
+
    当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测(type inference)来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，只要检查你赋的值即可。
    
+
    因为有类型推测，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
    
+
    当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个字面量(literal value 或 literal)即可触发类型推测。（字面量就是会直接出现在你代码中的值，比如42和3.14159。）
    
+
    例如，如果你给一个新常量赋值42并且没有标明类型，Swift 可以推测出常量类型是Int，因为你给它赋的初始值看起来像一个整数：
    
 
    let meaningOfLife = 42
 // meaningOfLife 会被推测为 Int 类型
-
    同理，如果你没有给浮点原始值标明类型，Swift 会推测你想要的是Double：
    
+

    同理，如果你没有给浮点字面量标明类型，Swift 会推测你想要的是Double：

    let pi = 3.14159
 // pi 会被推测为 Double 类型

    当推测浮点数的类型时，Swift 总是会选择Double而不是Float。

    如果表达式中同时出现了整数和浮点数，会被推测为Double类型：

    let anotherPi = 3 + 0.14159
 // anotherPi 会被推测为 Double 类型
-

    原始值3没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为Double类型。

    -

    数值类原始值

    -

    整数原始值可以被写作：

    +

    原始值3没有显式声明类型，而表达式中出现了一个浮点字面量，所以表达式会被推测为Double类型。

    +

    +

    数值型字面量

    +

    整数字面量可以被写作：

    • 一个十进制数，没有前缀
    • 一个二进制数，前缀是0b
    • 一个八进制数，前缀是0o
    • 一个十六进制数，前缀是0x
    -

    下面的所有整数原始值的十进制值都是17:

    +

    下面的所有整数字面量的十进制值都是17:

    let decimalInteger = 17
 let binaryInteger = 0b10001       // 二进制的17
 let octalInteger = 0o21           // 八进制的17
-let hexadecimalInteger = 0x11     // 十六机制的17
-

    浮点原始值可以是十进制（没有前缀）或者是十六进制（前缀是0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点原始值还有一个可选的指数，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p来指定。

    -

    如果一个十进制数的指数为exp，那这个数相当于基数和10^exp的乘积：

    +let hexadecimalInteger = 0x11 // 十六进制的17 +

    浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的指数(exponent)，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p来指定。

    +

    如果一个十进制数的指数为exp，那这个数相当于基数和$10^{exp}$的乘积：

      -
    • 1.25e2 表示 1.25 × 10^2，等于 125.0。
      • -
    • 1.25e-2 表示 1.25 × 10^-2，等于 0.0125。
      • +
    • 1.25e2 表示 $1.25 × 10^{2}$，等于 125.0。
      • +
    • 1.25e-2 表示 $1.25 × 10^{-2}$，等于 0.0125。
    -

    如果一个十六进制数的指数为exp，那这个数相当于基数和2^exp的乘积：

    +

    如果一个十六进制数的指数为exp，那这个数相当于基数和$2^{exp}$的乘积：

      -
    • 0xFp2 表示 15 × 2^2，等于 60.0。
      • -
    • 0xFp-2 表示 15 × 2^-2，等于 3.75。
      • +
    • 0xFp2 表示 $15 × 2^{2}$，等于 60.0。
      • +
    • 0xFp-2 表示 $15 × 2^{-2}$，等于 3.75。
    -

    下面的这些浮点原始值都等于十进制的12.1875：

    +

    下面的这些浮点字面量都等于十进制的12.1875：

    let decimalDouble = 12.1875
 let exponentDouble = 1.21875e1
 let hexadecimalDouble = 0xC.3p0
-

    数值类原始值可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响原始值：

    +

    数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

    let paddedDouble = 000123.456
 let oneMillion = 1_000_000
 let justOverOneMillion = 1_000_000.000_000_1
-

    数值类型转换

    -

    通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类原始值的类型推测。 +

    +

    数值型类型转换

    +

    通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推测。 只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。

    整数转换

    -

    不同整数类型的变量和常量可以存储不同大小的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

    +

    不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

    let cannotBeNegative: UInt8 = -1
 // UInt8 类型不能存储负数，所以会报错
 let tooBig: Int8 = Int8.max + 1
 // Int8 类型不能存储超过最大值的数，所以会报错
-

    因为每一个整数类型都可以存储不同范围的值，你必须根据情况来选择不同的转换方法。不同的转换方法可以暴露出隐藏的转换错误并让你的代码更加清晰。

    -

    要将一种数字类型转换成另一种，你要用当前值来初始化一个新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand类型是UInt16，然而常量one类型是Uint8。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：

    +

    由于每中整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。

    +

    要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是Uint8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：

    let twoThousand: UInt16 = 2_000
 let one: UInt8 = 1
 let twoThousandAndOne = twoThousand + UInt16(one)
-

    现在两个数字的类型都是UInt16，可以进行相加。目标常量twoThousandAndOne的类型被推测为UInt16，因为它是两个UInt16值的合。

    -

    SomeType(ofInitialValue)是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，UInt16有一个构造器，可以接受一个UInt8类型的值，所以这个构造器可以用现有的UInt8来创建一个新的UInt16。注意，你并不能传入任意类型的值，只能传入UInt16内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），详情参见扩展(链接待添加).

    +

    现在两个数字的类型都是UInt16，可以进行相加。目标常量twoThousandAndOne的类型被推测为UInt16，因为它是两个UInt16值的和。

    +

    SomeType(ofInitialValue)是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，UInt16有一个构造器，可以接受一个UInt8类型的值，所以这个构造器可以用现有的UInt8来创建一个新的UInt16。注意，你并不能传入任意类型的值，只能传入UInt16内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考扩展。

    整数和浮点数转换

    整数和浮点数的转换必须显式指定类型：

    let three = 3
@@ -778,26 +811,29 @@ let pointOneFourOneFiveNine = 0.14159
 let pi = Double(three) + pointOneFourOneFiveNine
 // pi 等于 3.14159，所以被推测为 Double 类型

    这个例子中，常量three的值被用来创建一个Double类型的值，所以加号两边的数类型相同。如果不进行转换，两者无法相加。

    -

    浮点数转换为整数也一样，整数类型可以用Double或者Float类型来初始化：

    +

    浮点数到整数的反向转换同样行，整数类型可以用Double或者Float类型来初始化：

    let integerPi = Int(pi)
 // integerPi 等于 3，所以被推测为 Int 类型

    当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说4.75会变成4，-3.9会变成-3。

    -

    注意：结合数字类常量和变量不同于结合数字类原始值。原始值3可以直接和原始值0.14159相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。

    +

    注意：

    +

    结合数字类常量和变量不同于结合数字类字面量。字面量3可以直接和字面量0.14159相加，因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。

    +

    类型别名

    -

    类型别名就是给现有类型定义一个可选名字。你可以使用typealias关键字来定义类型别名。

    +

    类型别名(type aliases)就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

    当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：

    typealias AudioSample = UInt16

    定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

    var maxAmplitudeFound = AudioSample.min
 // maxAmplitudeFound 现在是 0

    本例中，AudioSample被定义为UInt16的一个别名。因为它是别名，AudioSample.min实际上是UInt16.min，所以会给maxAmplitudeFound赋一个初值0。

    +

    布尔值

    -

    Swift 有一个基本的布尔类型，叫做Bool。布尔值是指逻辑，因为它们只能是真或者假。Swift 有两个布尔常量，true和false：

    +

    Swift 有一个基本的布尔(Boolean)类型，叫做Bool。布尔值指逻辑上的(logical)，因为它们只能是真或者假。Swift 有两个布尔常量，true和false：

    let orangesAreOrange = true
 let turnipsAreDelicious = false
-

    orangesAreOrange和turnipsAreDelicious的类型会被推测为Bool，因为它们的初值是布尔原始值。就像之前提到的Int和Double一样，如果你创建变量的时候给它们赋值true或者false，那你不需要给常量或者变量标明Bool类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推测，这让 Swift 代码更加简洁并且可读性更高。

    +

    orangesAreOrange和turnipsAreDelicious的类型会被推测为Bool，因为它们的初值是布尔字面量。就像之前提到的Int和Double一样，如果你创建变量的时候给它们赋值true或者false，那你不需要将常量或者变量声明为Bool类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推测，这让 Swift 代码更加简洁并且可读性更高。

    当你编写条件语句比如if语句的时候，布尔值非常有用：

    if turnipsAreDelicious {
     println("Mmm, tasty turnips!")
@@ -805,7 +841,7 @@ let turnipsAreDelicious = false
     println("Eww, turnips are horrible.")
 }
 // 输出 "Eww, turnips are horrible."
-

    条件语句比如if语句的详细介绍参见控制流(待添加链接)。

    +

    条件语句，例如if，请参考控制流。

    如果你在需要使用Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：

    let i = 1
 if i {
@@ -816,22 +852,23 @@ if i {
 if i == 1 {
     // 这个例子会编译成功
 }
-

    i == 1的比较结果是Bool类型，所以第二个例子可以通过类型检查。类似i == 1这样的比较会在基本操作符(待添加链接)中详细讨论。

    -

    和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的作用总是在意料之中。

    +

    i == 1的比较结果是Bool类型，所以第二个例子可以通过类型检查。类似i == 1这样的比较，请参考基本操作符。

    +

    和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。

    +

    元组

    -

    元组把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。

    -

    下面这个例子中，(404, "Not Found")是一个描述 HTTP 状态码的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个404 Not Found状态码。

    +

    元组（tuples）把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。

    +

    下面这个例子中，(404, "Not Found")是一个描述 HTTP 状态码（HTTP status code）的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个404 Not Found状态码。

    let http404Error = (404, "Not Found")
 // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")
-

    (404, "Not Found")元组把一个Int值和一个String值组合起来表示 HTTP 状态码的两个部分：一个数字和一个可以读懂的描述。这个元组可以被描述为“一个类型为(Int, String)的元组”。

    -

    你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为(Int, Int, Int)或者(String, Bool)或者包含其他类型的元组。

    -

    你可以将一个元组的内容分解成单独的常量和变量，然后你就可以正常使用它们了：

    +

    (404, "Not Found")元组把一个Int值和一个String值组合起来表示 HTTP 状态码的两个部分：一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为(Int, String)的元组”。

    +

    你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为(Int, Int, Int)或者(String, Bool)或者其他任何你想要的组合的元组。

    +

    你可以将一个元组的内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

    let (statusCode, statusMessage) = http404Error
 println("The status code is \(statusCode)")
 // 输出 "The status code is 404"
 println("The status message is \(statusMessage)")
 // 输出 "The status message is Not Found"
-

    如果你只需要一部分元组值，分解的时候可以把要忽略的部分设置成_：

    +

    如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

    let (justTheStatusCode, _) = http404Error
 println("The status code is \(justTheStatusCode)")
 // 输出 "The status code is 404"
@@ -847,44 +884,48 @@ println("The status message is \(http404Error.1)")
 // 输出 "The status code is 200"
 println("The status message is \(http200Status.description)")
 // 输出 "The status message is OK"
-

    作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String)元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。详情参见返回多个值的函数(待添加链接)。

    +

    作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String)元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值(06_Functions.html#Function_Parameters_and_Return_Values)。

    -

    注意：元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。详情参见类和结构体(待添加链接)。

    +

    注意：

    +

    元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考类和结构体。

    +

    可选

    -

    使用可选来处理值可能缺失的情况。可选表示：

    +

    使用可选（optionals）来处理值可能缺失的情况。可选表示：

      -
    • 有值，等于 x
      • +
    • 有值，等于 x

    或者

      -
    • 没有值
      • +
    • 没有值
    -

    注意：C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。

    +

    注意：

    +

    C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。

    来看一个例子。Swift 的String类型有一个叫做toInt的方法，作用是将一个String值转换成一个Int值。然而，并不是所有的字符串都可以转换成一个整数。字符串"123"可以被转换成数字123，但是字符串"hello, world"不行。

    下面的例子使用toInt方法来尝试将一个String转换成Int：

    let possibleNumber = "123"
 let convertedNumber = possibleNumber.toInt()
 // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
-

    因为toInt方法可能会失败，所以它返回一个可选的Int，而不是一个Int。一个可选的Int被写作Int?而不是Int。问号暗示包含的值是可选，也就是说可能包含Int值也可能不包含值。（不能包含其他任何值比如Bool值或者String值。只能是Int或者什么都没有。）

    +

    因为toInt方法可能会失败，所以它返回一个可选的（optional）Int，而不是一个Int。一个可选的Int被写作Int?而不是Int。问号暗示包含的值是可选，也就是说可能包含Int值也可能不包含值。（不能包含其他任何值比如Bool值或者String值。只能是Int或者什么都没有。）

    if 语句以及强制解析

    你可以使用if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是false。

    -

    当你确定可选包含值之后，你可以在可选的名字后面加一个!来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析：

    +

    当你确定可选包确实含值之后，你可以在可选的名字后面加一个感叹号(!)来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析（forced unwrapping）：

    if convertedNumber {
     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语句的内容参见控制流(待添加链接)。

    +

    更多关于if语句的内容，请参考控制流。

    -

    注意：使用!来获取一个不存在的可选值会导致运行时错误。。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

    +

    注意：

    +

    使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

    可选绑定

    -

    使用可选绑定来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选的值进行判断并把值赋给一个常量或者变量。if和while语句详情参见控制流。

    -

    像下面这样写一个可选绑定：

    +

    使用可选绑定（optional binding）来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选的值进行判断并把值赋给一个常量或者变量。if和while语句，请参考控制流。

    +

    像下面这样在if语句中写一个可选绑定：

    if let constantName = someOptional {
     statements
 }
@@ -897,8 +938,8 @@ let convertedNumber = possibleNumber.toInt()
 // 输出 "123 has an integer value of 123"

    这段代码可以被理解为：

    “如果possibleNumber.toInt返回的可选Int包含一个值，创建一个叫做actualNumber的新常量并将可选包含的值赋给它。”

    -

    如果转换成功，actualNumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualNumber只被用来输出转换结果。

    -

    你可以在可选绑定中使用常量和变量。如果你想在if语句的第一个分支中操作actualNumber的值，你可以改成if var actualNumber，这样可选包含的值就会被赋给一个变量。

    +

    如果转换成功，actualNumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualNumber只被用来输出转换结果。

    +

    你可以在可选绑定中使用常量和变量。如果你想在if语句的第一个分支中操作actualNumber的值，你可以改成if var actualNumber，这样可选包含的值就会被赋给一个变量而非常量。

    nil

    你可以给可选变量赋值为nil来表示它没有值：

    var serverResponseCode: Int? = 404
@@ -906,50 +947,55 @@ let convertedNumber = possibleNumber.toInt()
 serverResponseCode = nil
 // serverResponseCode 现在不包含值
    -

    注意：nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。

    +

    注意：

    +

    nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。

    如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为nil：

    var surveyAnswer: String?
 // surveyAnswer 被自动设置为 nil
    -

    注意：Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil，不只是对象类型。

    +

    注意：

    +

    Swift 的nil和 Objective-C 中的nil并不一样。在 Objective-C 中，nil是一个指向不存在对象的指针。在 Swift 中，nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil，不只是对象类型。

    隐式解析可选

    如上所述，可选暗示了常量或者变量可以“没有值”。可选可以通过if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。

    -

    有时候在程序架构中，第一次被赋值之后，可以确定一个可选总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。

    -

    这种类型的可选被定义为隐式解析可选。把后缀?改成!来声明一个隐式解析可选，比如String!。

    -

    当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，详情参见无主引用和隐式解析可选属性(Unowned References and Implicitly Unwrapped Optional Properties待添加链接)。

    +

    有时候在程序架构中，第一次被赋值之后，可以确定一个可选总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。

    +

    这种类型的可选被定义为隐式解析可选（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选。

    +

    当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，请参考类实例之间的循环强引用。

    一个隐式解析可选其实就是一个普通的可选，但是可以被当做非可选来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选String和隐式解析可选String之间的区别：

    let possibleString: String? = "An optional string."
 println(possibleString!) // 需要惊叹号来获取值
 // 输出 "An optional string."
 
 let assumedString: String! = "An implicitly unwrapped optional string."
-println(assumedString)  // 不需要惊叹号
+println(assumedString)  // 不需要感叹号
 // 输出 "An implicitly unwrapped optional string."
-

    你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把惊叹号放到类型的结尾，而不是每次获取值的变量结尾。

    +

    你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。

    -

    注意：如果你在隐式解析可选没有值的时候尝试获取，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。

    +

    注意：

    +

    如果你在隐式解析可选没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。

    -

    你仍然可以把隐式解析可选当做普通可选来判断它是否包含值： - if assumedString { - println(assumedString) - } - // 输出 "An implicitly unwrapped optional string."

    -

    你也可以在可选绑定中使用隐式解析可选来检查并解析它的值： - if let definiteString = assumedString { - println(definiteString) - } - // 输出 "An implicitly unwrapped optional string."

    -
    -

    注意：如果一个变量之后可能变成nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

    +

    你仍然可以把隐式解析可选当做普通可选来判断它是否包含值：

    +
    if assumedString {
+    println(assumedString)
+}
+// 输出 "An implicitly unwrapped optional string."
+

    你也可以在可选绑定中使用隐式解析可选来检查并解析它的值：

    +
    if let definiteString = assumedString {
+    println(definiteString)
+}
+// 输出 "An implicitly unwrapped optional string."
+
    +

    注意：

    +

    如果一个变量之后可能变成nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。

    +

    断言

    -

    可选可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能并不需要继续执行。这时，你可以在你的代码中触发一个断言来结束代码运行并通过调试来找到值缺失的原因。

    -

    使用断言来调试

    +

    可选可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能并不需要继续执行。这时，你可以在你的代码中触发一个断言（assertion）来结束代码运行并通过调试来找到值缺失的原因。

    +

    使用断言进行调试

    断言会在运行时判断一个逻辑条件是否为true。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为true，代码运行会继续进行；如果条件判断为false，代码运行停止，你的应用被终止。

    如果你的代码在调试环境下触发了一个断言，比如你在 Xcode 中构建并运行一个应用，你可以清楚地看到不合法的状态发生在哪里并检查断言被触发时你的应用的状态。此外，断言允许你附加一条调试信息。

    -

    你可以使用全局assert函数来写一个断言。给assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为false的时候这条信息会被显示：

    +

    你可以使用全局assert函数来写一个断言。向assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为false的时候这条信息会被显示：

    let age = -3
 assert(age >= 0, "A person's age cannot be less than zero")
 // 因为 age < 0，所以断言会触发
@@ -957,15 +1003,16 @@ assert(age >= 0, "A person's age cannot be less than zero")
 
    断言信息不能使用字符串插值。断言信息可以省略，就像这样：
    
 
    assert(age >= 0)
 
    何时使用断言
    
-
    当条件可能为假时使用断言，但是最终一定要保证条件为真，这样你的代码才能继续运行。断言的适用情景：
    
+
    当条件可能为假时使用断言，但是最终一定要保证条件为真，这样你的代码才能继续运行。断言的适用情景：
    
 
      
-
    • 整数的下标(subscript)索引被传入一个自定义下标实现，但是下标索引值可能太小或者太大。
      • 
+
    • 整数的附属脚本索引被传入一个自定义附属脚本实现，但是下标索引值可能太小或者太大。
      • 
 
    • 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
      • 
 
    • 一个可选值现在是nil，但是后面的代码运行需要一个非nil值。
      • 
 
    
-
    查看下标(链接待添加)和函数(链接待添加)。
    
+
    请参考附属脚本和函数。
    
 
    
-
    注意：断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
    
+
    注意：
    
+
    断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
    
 
    
 
                     
@@ -1012,6 +1059,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/02_Basic_Operators.html b/chapter2/02_Basic_Operators.html
index 4e97ab9f..a5c126fd 100644
--- a/chapter2/02_Basic_Operators.html
+++ b/chapter2/02_Basic_Operators.html
@@ -5,12 +5,12 @@
         
         
         
-        基本运算符 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
    
+    
    
     
    
     
     
@@ -98,7 +98,7 @@
     
     
    
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
    
 
    
 
@@ -119,7 +119,7 @@
         
 
         
  • 
-             Introduction
+             序
         
    • 
         
     
@@ -331,7 +331,7 @@
         
  • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,167 +587,176 @@
 
                 
    
                 
-                    
    
+                    
    
                     
-                        
    基本运算符
    
+                        
    
+
    翻译：xielingwang
    
+
    校对：Evilcome
    
+
    
+
    基本运算符
    
 
    
 
    本页包含内容：
    
 
-
    运算符是检查，改变，合并值的特殊符号或短语。例如，加号+把计算两个数的和(如 let i = 1 + 2)。复杂些的运行算包括逻辑与&&(如 if enteredDoorCode && passedRetinaScan)，还有自增运算符++i这样让自身加一的便捷运算。
    
-
    Swift支持大部分标准C语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符=不返回值，以防止错把等号==写成赋值号=而导致Bug。数值运算符(+，-，*，/，%等)会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你选择使用Swift的溢出运算符来玩溢出。具体使用请移步溢出运算符。
    
-
    区别于C语言，在Swift中你可以对浮点数进行取余运算(%)，还提供了C语言没有的表达两数之间的值的区间运算符，(a..b和a...b)，这方便我们表达一个区间内的数值。
    
-
    本章节只描述了Swift中的基本运算符，高级运算符包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
    
+
    运算符是检查，改变，合并值的特殊符号或短语。例如，加号+将两个数相加（如let i = 1 + 2）。复杂些的运行算例如逻辑与运算符&&（如if enteredDoorCode && passedRetinaScan），又或让 i 值加1的便捷运算符自增运算符++i等。
    
+
    Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符（=）不返回值，以防止把想要判断相等运算符（==）的地方写成赋值符导致的错误。数值运算符（+，-，*，/，%等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见溢出运算符。
    
+
    区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（%），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符，（a..b和a...b），这方便我们表达一个区间内的数值。
    
+
    本章节只描述了 Swift 中的基本运算符，高级运算符包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
    
 
    
 
    术语
    
-
    运算符有一目，双目和三目运算符。
    
+
    运算符有一元，二元和三元运算符。
    
 
      
-
    • 一目运算符对单一操作对象操作，如-a。一目运算符分前置符和后置运算符，前置运算符需紧排操作对象之前，如!b，后置运算符需紧跟操作对象之后，如i++，
      • 
-
    • 双目运算符操作两个操作对象，如 2 + 3。是中置的，因为它们出现在两个操作对象之间。
      • 
-
    • 三目运算符操作三个操作对象，和C语言一样，Swift只有一个三目运算符，就是三目条件运算符 a？b：c。
      • 
+
    • 一元运算符对单一操作对象操作（如-a）。一元运算符分前置符和后置运算符，前置运算符需紧排操作对象之前（如!b），后置运算符需紧跟操作对象之后（如i++）。
      • 
+
    • 二元运算符操作两个操作对象（如2 + 3），是中置的，因为它们出现在两个操作对象之间。
      • 
+
    • 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三元条件运算符（a ? b : c）。
      • 
 
    
-
    受运算符影响的值叫操作数，在表达式1 + 2中，加号+是双目运算符，它的两个操作数是值1和2。
    
+
    受运算符影响的值叫操作数，在表达式1 + 2中，加号+是二元运算符，它的两个操作数是值1和2。
    
 
    
 
    赋值运算符
    
-
    赋值运算 a = b，表示用b的值来初始化或更新a的值。
    
+
    赋值运算（a = b），表示用b的值来初始化或更新a的值：
    
 
    let b = 10
 var a = 5
 a = b
 // a 现在等于 10
 
    
-
    如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量
    
+
    如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量：
    
 
    let (x, y) = (1, 2)
 // 现在 x 等于 1, y 等于 2
-
    与C语言和Objective-C不同，Swift的赋值操作并不返回任何值。所以以下代码是错误的：
    
+

    • 与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：

    if x = y {
     // 此句错误, 因为 x = y 并不返回任何值
 }
    -

    这个特性使得你不无法把==错写成=了，由于if x = y是错误代码，Swift从底层帮你避免了这些代码错误。

    +

    这个特性使得你无法把（==）错写成（=）了，由于if x = y是错误代码，Swift 从底层帮你避免了这些代码错误。

    数值运算

    -

    Swift让所有数值类型都支持了基本的四则运算：

    +

    Swift 让所有数值类型都支持了基本的四则运算：

      -
    • 加法+
      • -
    • 减法-
      • -
    • 乘法*
      • -
    • 除法/
      • +
    • 加法（+）
      • +
    • 减法（-）
      • +
    • 乘法（*）
      • +
    • 除法（/）
    1 + 2       // 等于 3
 5 - 3       // 等于 2
 2 * 3       // 等于 6
 10.0 / 2.5  // 等于 4.0
    -

    与C语言和Objective-C不同的是，Swift默认不允许在数值运算中出现溢出情况。但你可以使用Swift的溢出运算符来达到你有目的的溢出，(如 a &+ b)。详情请移步：溢出运算符。

    -

    加法操作+也用于字符串的拼接：

    +

    与 C 语言和 Objective-C 不同的是，Swift 默认不允许在数值运算中出现溢出情况。但你可以使用 Swift 的溢出运算符来达到你有目的的溢出（如a &+ b）。详情参见溢出运算符。

    +

    加法运算符也用于String的拼接：

    "hello, " + "world"  // 等于 "hello, world"
    -

    两个字符类型或一个字符类型和一个字符串类型，相加会生成一个新的字符串类型：

    +

    两个Character值或一个String和一个Character值，相加会生成一个新的String值：

    let dog: Character = "d"
 let cow: Character = "c"
 let dogCow = dog + cow
 // 译者注: 原来的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符
 // dogCow 现在是 "dc"
    -

    详细请点击字符，字符串的拼接。

    +

    详情参见字符，字符串的拼接。

    求余运算

    -

    求余运算 a % b 是计算b的多少倍刚刚好可以容入a，多出来的那部分叫余数。

    +

    求余运算（a % b）是计算b的多少倍刚刚好可以容入a，返回多出来的那部分（余数）。

    -

    注意： -求余运算(%)在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。

    +

    注意：

    +

    求余运算（%）在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。

    -

    我们来谈谈取余是怎么回事，计算9 % 4，你先计算出4的多少倍会刚好可以容入9中。

    -

    2倍，非常好，那余数是1(用橙色标出)

    +

    我们来谈谈取余是怎么回事，计算9 % 4，你先计算出4的多少倍会刚好可以容入9中：

    Art/remainderInteger_2x.png

    -

    在Swift中这么来表达

    +

    2倍，非常好，那余数是1（用橙色标出）

    +

    在 Swift 中这么来表达：

    9 % 4    // 等于 1
    -

    为了得到 a % b 的结果，%计算了以下等式，并输出余数作为结果：

    +

    为了得到a % b的结果，%计算了以下等式，并输出余数作为结果：

    a = (b × 倍数) + 余数

    当倍数取最大值的时候，就会刚好可以容入a中。

    把9和4代入等式中，我们得1：

    9 = (4 × 2) + 1

    同样的方法，我来们计算 -9 % 4：

    -
    -9 % 4   // 等于 -1
-

    把-9和4代入等式，-2是取到的最大整数：

    +
    -9 % 4   // 等于 -1
+
    +

    把-9和4代入等式，-2是取到的最大整数：

    -9 = (4 × -2) + -1

    余数是-1。

    -

    在对负数-b求余时，-b的符号会被忽略。这意味着 a % b 和 a % -b的结果是相同的。

    +

    在对负数b求余时，b的符号会被忽略。这意味着 a % b 和 a % -b的结果是相同的。

    浮点数求余计算

    -

    不同于C和Objective-C，Swift中是可以对浮点数进行求余的。

    +

    不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。

    8 % 2.5 // 等于 0.5
    -

    这个例子中，8除于2.5等于3余0.5，所以结果是0.5。

    +

    这个例子中，8除于2.5等于3余0.5，所以结果是一个Double值0.5。

    Art/remainderFloat_2x.png

    自增和自增运算

    -

    和C一样，Swift也提供了方便对变量本身加1或减1的自增++和自减--的运算符。其操作对象可以是整形和浮点型。 +

    和 C 语言一样，Swift 也提供了方便对变量本身加1或减1的自增（++）和自减（--）的运算符。其操作对象可以是整形和浮点型。 ‌

    -
    var i = 0
+
    var i = 0
 ++i      // 现在 i = 1
-
    每调用一次++i，i的值就会加1。
-实际上，++i是 i = i + 1 的简写，而--i是 i = i - 1的简写。
    
+
    +

    每调用一次++i，i的值就会加1。实际上，++i是i = i + 1的简写，而--i是i = i - 1的简写。

    ++和--既是前置又是后置运算。++i，i++，--i和i--都是有效的写法。

    我们需要注意的是这些运算符修改了i后有一个返回值。如果你只想修改i的值，那你就可以忽略这个返回值。但如果你想使用返回值，你就需要留意前置和后置操作的返回值是不同的。

    -

    当++前置的时候，先自増再返回。

    -

    当++后置的时候，先返回再自增。

    -

    不懂？我们看例子：

    +
      +

    • 当++前置的时候，先自増再返回。

      +
      • +

    • 当++后置的时候，先返回再自增。

      +
      • +
    +

    例如：

    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。

    -

    而 let c = a++，是先返回了a的值，然后a才加1。所以c得到了a的旧值1，而a加1后变成2。

    +

    上述例子，let b = ++a先把a加1了再返回a的值。所以a和b都是新值1。

    +

    而let c = a++，是先返回了a的值，然后a才加1。所以c得到了a的旧值1，而a加1后变成2。

    除非你需要使用i++的特性，不然推荐你使用++i和--i，因为先修改后返回这样的行为更符合我们的逻辑。

    -

    单目负号

    -

    数值的正负号可以使用前缀-(即单目负号)来切换：

    +

    一元负号

    +

    数值的正负号可以使用前缀-（即一元负号）来切换：

    let three = 3
 let minusThree = -three       // minusThree 等于 -3
 let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"
    -

    单目负号写在操作数之前，中间没有空格。

    -

    单目正号

    -

    单目正号+不做任何改变地返回操作数的值。

    +

    一元负号（-）写在操作数之前，中间没有空格。

    +

    一元正号

    +

    一元正号（+）不做任何改变地返回操作数的值。

    let minusSix = -6
 let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
    -

    虽然单目+做无用功，但当你在使用单目负号来表达负数时，你可以使用单目正号来表达正数，如此你的代码会具有对称美。

    +

    虽然一元+做无用功，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。

    -

    复合赋值

    -

    如同强大的C语言，Swift也提供把其他运算符和赋值运算=组合的复合赋值运算符，加赋运算+=是其中一个例子：

    +

    复合赋值（Compound Assignment Operators）

    +

    如同强大的 C 语言，Swift 也提供把其他运算符和赋值运算（=）组合的复合赋值运算符，加赋运算（+=）是其中一个例子：

    var a = 1
 a += 2 // a 现在是 3
    -

    表达式 a += 2 是 a = a + 2 的简写，一个加赋运算就把加法和赋值两件事完成了。

    +

    表达式a += 2是a = a + 2的简写，一个加赋运算就把加法和赋值两件事完成了。

    -

    注意： -复合赋值运算没有返回值，let b = a += 2 这类代码是错误。这不同于上面提到的自增和自减运算符。

    +

    注意：

    +

    复合赋值运算没有返回值，let b = a += 2这类代码是错误。这不同于上面提到的自增和自减运算符。

    在表达式章节里有复合运算符的完整列表。 ‌

    比较运算

    -

    所有标准C中的比较运算都可以在Swift中使用。

    +

    所有标准 C 语言中的比较运算都可以在 Swift 中使用。

      -
    • 等于 a == b
      • -
    • 不等于 a！= b
      • -
    • 大于 a > b
      • -
    • 小于 a < b
      • -
    • 大于等于 a >= b
      • -
    • 小于等于 a <= b
      • +
    • 等于（a == b）
      • +
    • 不等于（a！= b）
      • +
    • 大于（a > b）
      • +
    • 小于（a < b）
      • +
    • 大于等于（a >= b）
      • +
    • 小于等于（a <= b）
    -

    注意： -Swift也提供恒等===和不恒等!==这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在类与结构。

    +

    注意：

    +

    Swift 也提供恒等===和不恒等!==这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在类与结构。

    每个比较运算都返回了一个标识表达式是否成立的布尔值：

    1 == 1   // true, 因为 1 等于 1
@@ -762,20 +771,20 @@ Swift也提供恒等===和不恒等!==这两个比较
 if name == "world" {
     println("hello, world")
 } else {
-    println("对不起, \(name), 我不认识你!")
+    println("I'm sorry \(name), but I don't recognize you")
 }
 // 输出 "hello, world", 因为 `name` 就是等于 "world"

    关于if语句，请看控制流。

    -

    三目条件运算

    -

    三目条件运算的特殊在于它是有三个操作数的运算符，它的原型是 问题？答案1：答案2。它简洁地表达根据 问题 成立与否作出二选一的操作。如果 问题 成立，返回 答案1 的结果; 如果不成立，返回 答案2 的结果。

    -

    使用三目条件运算简化了以下代码：

    +

    三元条件运算(Ternary Conditional Operator)

    +

    三元条件运算的特殊在于它是有三个操作数的运算符，它的原型是问题？答案1：答案2。它简洁地表达根据问题成立与否作出二选一的操作。如果问题成立，返回答案1的结果; 如果不成立，返回答案2的结果。

    +

    使用三元条件运算简化了以下代码：

    if question: {
-  answer1
+    answer1
 }
 else {
-  answer2
+    answer2
 }

    这里有个计算表格行高的例子。如果有表头，那行高应比内容高度要高出50像素; 如果没有表头，只需高出20像素。

    @@ -795,17 +804,17 @@ if hasHeader { } // rowHeight 现在是 90 -

    第一段代码例子使用了三目条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将rowHeight定义成变量，因为它的值无需在if语句中改变。

    -

    三目条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三目条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三目条件运算符。

    +

    第一段代码例子使用了三元条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将rowHeight定义成变量，因为它的值无需在if语句中改变。

    +

    三元条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三元条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三元条件运算符。

    区间运算符

    -

    Swift提供了两个方便表达一个区间的值的运算符。

    +

    Swift 提供了两个方便表达一个区间的值的运算符。

    闭区间运算符

    -

    闭区间运算符a...b定义一个包含从a到b(包括a和b)的所有值的区间。 +

    闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的所有值的区间。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for-in循环中：

    for index in 1...5 {
-  println("\(index) * 5 = \(index * 5)")
+      println("\(index) * 5 = \(index * 5)")
 }
 // 1 * 5 = 5
 // 2 * 5 = 10
@@ -815,7 +824,7 @@ if hasHeader {

    关于for-in，请看控制流。

    半闭区间

    -

    半闭区间a..b定义一个从a到b但不包括b的区间。 +

    半闭区间（a..b）定义一个从a到b但不包括b的区间。 之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。

    半闭区间的实用性在于当你使用一个0始的列表(如数组)时，非常方便地从0数到列表的长度。

    let names = ["Anna", "Alex", "Brian", "Jack"]
@@ -828,33 +837,30 @@ for i in 0..count {
 // 第 3 个人叫 Brian
 // 第 4 个人叫 Jack
    -
    -

    注意： -数组有4个元素，但0..count只数到 3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅数组。

    -
    +

    数组有4个元素，但0..count只数到3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅数组。

    逻辑运算

    -

    逻辑运算的操作对象是逻辑布尔值。Swift支持基于C语言的三个标准逻辑运算。

    +

    逻辑运算的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。

      -
    • 逻辑非!a
      • -
    • 逻辑与 a && b
      • -
    • 逻辑或 a || b
      • +
    • 逻辑非（!a）
      • +
    • 逻辑与（a && b）
      • +
    • 逻辑或（a || b）

    逻辑非

    -

    逻辑非运算!a对一个布尔值取反，使得true变false，false变true。

    -

    它是一个前置运算符，需出现在操作数之前，且不加空格。读作 非 a，然后我们看以下例子：

    +

    逻辑非运算（!a）对一个布尔值取反，使得true变false，false变true。

    +

    它是一个前置运算符，需出现在操作数之前，且不加空格。读作非 a，然后我们看以下例子：

    let allowedEntry = false
 if !allowedEntry {
     println("ACCESS DENIED")
 }
-// prints "ACCESS DENIED"
+// 输出 "ACCESS DENIED"

    if！allowedEntry语句可以读作 "如果 非 alowed entry。"，接下一行代码只有在如果 "非 allow entry" 为true，即allowEntry为false时被执行。

    在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。

    逻辑与

    -

    逻辑与 a && b 表达了只有a和b的值都为true时，整个表达式的值才会是true。

    -

    只要任意一个值为false，整个表达式的值就为false。事实上，如果第一个值为false，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算"。

    -

    以下例子，只有两个值都为值的时候才允许进入：

    +

    逻辑与（a && b）表达了只有a和b的值都为true时，整个表达式的值才会是true。

    +

    只要任意一个值为false，整个表达式的值就为false。事实上，如果第一个值为false，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。

    +

    以下例子，只有两个Bool值都为true值的时候才允许进入：

    let enteredDoorCode = true
 let passedRetinaScan = false
 if enteredDoorCode && passedRetinaScan {
@@ -862,12 +868,12 @@ if enteredDoorCode && passedRetinaScan {
 } else {
     println("ACCESS DENIED")
 }
-// 输出 "ACCESS DENIED
+// 输出 "ACCESS DENIED"

    逻辑或

    -

    逻辑或 a || b 是一个由两个连续的|组成的中置运算符。它表示了两个逻辑表达式的其中一个为true，整个表达式就为true。

    +

    逻辑或（a || b）是一个由两个连续的|组成的中置运算符。它表示了两个逻辑表达式的其中一个为true，整个表达式就为true。

    同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为true时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。

    -

    以下示例代码中，第一个布尔值hasDoorKey为false，但第二个值knowsOverridePassword为true，所以整个表达是true，于是允许进入：

    +

    以下示例代码中，第一个布尔值（hasDoorKey）为false，但第二个值（knowsOverridePassword）为true，所以整个表达是true，于是允许进入：

    let hasDoorKey = false
 let knowsOverridePassword = true
 if hasDoorKey || knowsOverridePassword {
@@ -890,16 +896,15 @@ if hasDoorKey || knowsOverridePassword {
 
    如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码，我们就能把门打开进入。
    
 
    前两种情况，我们都不满足，所以前两个简单逻辑的结果是false，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是true。
    
 
    使用括号来明确优先级
    
-
    为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确。
    
+
    为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确：
    
 
    if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
     println("Welcome!")
 } else {
     println("ACCESS DENIED")
 }
-// prints "Welcome!"
+// 输出 "Welcome!"
 
    
-
    这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。
    
-
    可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！
    
+
    这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！
    @@ -945,6 +950,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/03_Strings_and_Characters.html b/chapter2/03_Strings_and_Characters.html index 46a968ff..97fb46be 100644 --- a/chapter2/03_Strings_and_Characters.html +++ b/chapter2/03_Strings_and_Characters.html @@ -5,12 +5,12 @@ - 字符串和字符 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,51 +587,50 @@
    -
    +
    -

    字符串和字符 (Strings and Characters)

    +
    +

    翻译：wh1100717

    +

    校对：Hawstein

    +
    +

    字符串和字符（Strings and Characters）

    本页包含内容：

    -

    String 是例如 "hello, world", "海贼王" 这样的有序的 Character (字符) 类型的值的集合，通过 String 类型来表示。

    -

    Swift 的 String 和 Character 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。 +

    String是例如“hello, world“”，“海贼王” 这样的有序的Character（字符）类型的值的集合，通过String类型来表示。

    +

    Swift 的String和Character类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。 创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。 字符串连接操作只需要简单地通过+号将两个字符串相连即可。 与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。

    -

    尽管语法简易，但 String 类型是一种快速、现代化的字符串实现。 -每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示 (representations) 来访问这些字符的支持。

    -

    Swift可以在常量、变量、字面量和表达式中进行字符串插值操作，可以轻松创建用于展示、存储和打印的自定义字符串。

    +

    尽管语法简易，但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(章节信息url需要替换)。

    +

    注意：

    +

    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。

    -

    字符串字面量 (String Literals)

    -
    +

    字符串字面量（String Literals）

    您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。 字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。

    字符串字面量可以用于为常量和变量提供初始值。

    let someString = "Some string literal value"
    -

    注意： -someString变量通过字符串字面量进行初始化，Swift 因此推断该变量为 String 类型。

    +

    注意：

    +

    someString变量通过字符串字面量进行初始化，Swift 因此推断该变量为String类型。

    字符串字面量可以包含以下特殊字符：

      @@ -649,21 +648,19 @@ let dollarSign = "\x24" // $, Unicode 标量 U+0024 let blackHeart = "\u2665" // ♥, Unicode 标量 U+2665 let sparklingHeart = "\U0001F496" // 💖, Unicode 标量 U+1F496

      -

      初始化空字符串 (Initializing an Empty String)

      -
      +

      初始化空字符串 (Initializing an Empty String)

      为了构造一个很长的字符串，可以创建一个空字符串作为初始值。 -可以将空的字符串字面量赋值给变量，也可以初始化一个新的 String 实例：

      +可以将空的字符串字面量赋值给变量，也可以初始化一个新的String实例：

      var emptyString = ""               // 空字符串字面量
 var anotherEmptyString = String()  // 初始化 String 实例
 // 两个字符串均为空并等价。
-

      您可以通过检查其 Boolean 类型的isEmpty属性来判断该字符串是否为空：

      +

      您可以通过检查其Boolean类型的isEmpty属性来判断该字符串是否为空：

      if emptyString.isEmpty {
     println("什么都没有")
 }
-// 输出 "什么都没有"
+// 打印输出："什么都没有"

      -

      字符串可变性 (String Mutability)

      -
      +

      字符串可变性 (String Mutability)

      您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：

      var variableString = "Horse"
 variableString += " and carriage"
@@ -672,28 +669,26 @@ let constantString = "Highlander"
 constantString += " and another Highlander"
 // 这会报告一个编译错误 (compile-time error) - 常量不可以被修改。
      -

      注意： -在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(NSString和NSMutableString)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。

      +

      注意：

      +

      在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(NSString和NSMutableString)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。

      -

      字符串是值类型 (Strings Are Value Types)

      -
      -

      Swift 的 String 类型是值类型。 +

      字符串是值类型（Strings Are Value Types）

      +

      Swift 的String类型是值类型。 如果您创建了一个新的字符串，那么当其进行常量、变量赋值操作或在函数/方法中传递时，会进行值拷贝。 任何情况下，都会对已有字符串值创建新副本，并对该新副本进行传递或赋值操作。 -值类型在 Structures and Enumerations Are Value Types(章节信息URL需要替换) 中进行了说明。

      +值类型在 结构体和枚举是值类型 中进行了说明。

      -

      注意： -与 Cocoa 中的NSString不同，当您在 Cocoa 中创建了一个NSString实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该NSString实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。

      +

      注意：

      +

      与 Cocoa 中的NSString不同，当您在 Cocoa 中创建了一个NSString实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该NSString实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。

      Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。 很明显无论该值来自于哪里，都是您独自拥有的。 您可以放心您传递的字符串本身不会被更改。

      在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。

      -

      使用字符 (Working with Characters)

      -
      -

      Swift 的 String 类型表示特定序列的 Character (字符) 类型值的集合。 +

      使用字符（Working with Characters）

      +

      Swift 的String类型表示特定序列的Character（字符） 类型值的集合。 每一个字符值代表一个 Unicode 字符。 您可利用for-in循环来遍历字符串中的每一个字符：

      for character in "Dog!🐶" {
@@ -704,30 +699,23 @@ constantString += " and another Highlander"
 // g
 // !
 // 🐶
-

      for-in 循环在For Loops(章节信息URL需要替换)中进行了详细描述。

      -

      另外，通过标明一个 Character 类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：

      +

      for-in 循环在 For Loops 中进行了详细描述。

      +

      另外，通过标明一个Character类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：

      let yenSign: Character = "¥"

      -

      计算字符数量 (Counting Characters)

      -
      +

      计算字符数量 (Counting Characters)

      通过调用全局countElements函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。

      let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
 println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
-// prints "unusualMenagerie has 40 characters"
+// 打印输出："unusualMenagerie has 40 characters"
      -

      注意： -不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。 -所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。 -因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。 -如果您正在处理一个长字符串，需要注意countElements函数必须遍历字符串中的字符以精准计算字符串的长度。

      -

      另外需要注意的是通过countElements返回的字符数量并不总是与包含相同字符的NSString的length属性相同。 -NSString的length属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。 -为了解决这个问题，NSString的length属性在被 Swift 的 String 访问时会成为utf16count。

      +

      注意：

      +

      不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意countElements函数必须遍历字符串中的字符以精准计算字符串的长度。

      +

      另外需要注意的是通过countElements返回的字符数量并不总是与包含相同字符的NSString的length属性相同。NSString的length属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，NSString的length属性在被 Swift 的String访问时会成为utf16count。

      -

      连接字符串和字符 (Concatenating Strings and Characters)

      -
      -

      字符串和字符的值可以通过加法运算符 (+) 相加在一起并创建一个新的字符串值：

      +

      连接字符串和字符 (Concatenating Strings and Characters)

      +

      字符串和字符的值可以通过加法运算符（+）相加在一起并创建一个新的字符串值：

      let string1 = "hello"
 let string2 = " there"
 let character1: Character = "!"
@@ -746,43 +734,41 @@ var welcome = "good morning"
 welcome += character1
 // welcome 现在等于 "good morning!"
      -

      注意： -您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。

      +

      注意：

      +

      您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。

      -

      字符串插值 (String Interpolation)

      -
      +

      字符串插值 (String Interpolation)

      字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。 您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：

      let multiplier = 3
 let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
-// message is "3 乘以 2.5 是 7.5"
+// message 是 "3 乘以 2.5 是 7.5"

      在上面的例子中，multiplier作为\(multiplier)被插入到一个字符串字面量中。 当创建字符串执行插值计算时此占位符会被替换为multiplier实际的值。

      multiplier的值也作为字符串中后面表达式的一部分。 该表达式计算Double(multiplier) * 2.5的值并将结果 (7.5) 插入到字符串中。 在这个例子中，表达式写为\(Double(multiplier) * 2.5)并包含在字符串字面量中。

      -

      注意： -您插值字符串中写在括号中的表达式不能包含非转义双引号 (") 和反斜杠 (\)，并且不能包含回车或换行符。

      +

      注意：

      +

      您插值字符串中写在括号中的表达式不能包含非转义双引号 (") 和反斜杠 (\)，并且不能包含回车或换行符。

      -

      比较字符串 (Comparing Strings)

      -
      +

      比较字符串 (Comparing Strings)

      Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。

      -
      字符串相等 (String Equality)
      +

      字符串相等 (String Equality)

      如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等：

      let quotation = "我们是一样一样滴."
 let sameQuotation = "我们是一样一样滴."
 if quotation == sameQuotation {
     println("这两个字符串被认为是相同的")
 }
-// prints "这两个字符串被认为是相同的"
+// 打印输出："这两个字符串被认为是相同的"

      -
      前缀/后缀相等 (Prefix and Suffix Equality)
      +

      前缀/后缀相等 (Prefix and Suffix Equality)

      通过调用字符串的hasPrefix/hasSuffix方法来检查字符串是否拥有特定前缀/后缀。 -两个方法均需要以字符串作为参数传入并传出 Boolean 值。 +两个方法均需要以字符串作为参数传入并传出Boolean值。 两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。

      下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：

      let romeoAndJuliet = [
@@ -806,9 +792,21 @@ for scene in romeoAndJuliet {
     }
 }
 println("There are \(act1SceneCount) scenes in Act 1")
-// prints "There are 5 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
+    }
+}
+println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
+// 打印输出："6 mansion scenes; 2 cell scenes”

      -
      大写和小写字符串 (Uppercase and Lowercase Strings)
      +

      大写和小写字符串（Uppercase and Lowercase Strings）

      您可以通过字符串的uppercaseString和lowercaseString属性来访问大写/小写版本的字符串。

      let normal = "Could you help me, please?"
 let shouty = normal.uppercaseString
@@ -816,21 +814,20 @@ let shouty = normal.uppercaseString
 let whispered = normal.lowercaseString
 // whispered 值为 "could you help me, please?"

      -

      Unicode

      -
      +

      Unicode

      Unicode 是一个国际标准，用于文本的编码和表示。 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。

      Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。

      -
      Unicode 术语 (Unicode Terminology)
      +

      Unicode 术语（Unicode Terminology）

      Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。 -字符的 unicode 标量是一个唯一的21位数字(和名称)，例如U+0061表示小写的拉丁字母A ("a")，U+1F425表示小幺鸡表情 ("🐥")

      -

      当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括UTF-8(以8位代码单元进行编码) 和UTF-16(以16位代码单元进行编码)。

      +字符的 unicode 标量是一个唯一的21位数字(和名称)，例如U+0061表示小写的拉丁字母A ("a")，U+1F425表示小鸡表情 ("🐥")

      +

      当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括UTF-8（以8位代码单元进行编码） 和UTF-16（以16位代码单元进行编码）。

      -
      字符串的 Unicode 表示 (Unicode Representations of Strings)
      +

      字符串的 Unicode 表示（Unicode Representations of Strings）

      Swift 提供了几种不同的方式来访问字符串的 Unicode 表示。

      您可以利用for-in来对字符串进行遍历，从而以 Unicode 字符的方式访问每一个字符值。 -该过程在 Working with Characters(章节信息URL需要替换) 中进行了描述。

      +该过程在 使用字符 中进行了描述。

      另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：

      • UTF-8 代码单元集合 (利用字符串的utf8属性进行访问)
        • @@ -840,32 +837,32 @@ let whispered = normal.lowercaseString

        下面由D``o``g``!和🐶(DOG FACE，Unicode 标量为U+1F436)组成的字符串中的每一个字符代表着一种不同的表示：

        let dogString = "Dog!🐶"

        -
        UTF-8
        +

        UTF-8

        您可以通过遍历字符串的utf8属性来访问它的UTF-8表示。 -其为 UTF8View 类型的属性，UTF8View 是无符号8位 (UInt8) 值的集合，每一个UInt8值都是一个字符的 UTF-8 表示：

        +其为UTF8View类型的属性，UTF8View是无符号8位 (UInt8) 值的集合，每一个UInt8值都是一个字符的 UTF-8 表示：

        for codeUnit in dogString.utf8 {
     print("\(codeUnit) ")
 }
 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) 是DOG FACE的4位 UTF-8 表示。

        +后四个代码单元值 (240, 159, 144, 182) 是DOG FACE的4字节 UTF-8 表示。

        -
        UTF-16
        +

        UTF-16

        您可以通过遍历字符串的utf16属性来访问它的UTF-16表示。 -其为 UTF16View 类型的属性，UTF16View 是无符号16位 (UInt16) 值的集合，每一个UInt16都是一个字符的 UTF-16 表示：

        +其为UTF16View类型的属性，UTF16View是无符号16位 (UInt16) 值的集合，每一个UInt16都是一个字符的 UTF-16 表示：

        for codeUnit in dogString.utf16 {
     print("\(codeUnit) ")
 }
 print("\n")
 // 68 111 103 33 55357 56374

        同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符D o g和!，他们的 UTF-16 代码单元和 UTF-8 完全相同。

        -

        第五和第六个代码单元值 (55357 and 56374) 是DOG FACE字符的UTF-16 表示。 +

        第五和第六个代码单元值 (55357 和 56374) 是DOG FACE字符的UTF-16 表示。 第一个值为U+D83D(十进制值为 55357)，第二个值为U+DC36(十进制值为 56374)。

        -
        Unicode 标量 (Unicode Scalars)
        +

        Unicode 标量 (Unicode Scalars)

        您可以通过遍历字符串的unicodeScalars属性来访问它的 Unicode 标量表示。 -其为 UnicodeScalarView 类型的属性， UnicodeScalarView 是UnicodeScalar的集合。 +其为UnicodeScalarView类型的属性， UnicodeScalarView是UnicodeScalar的集合。 UnicodeScalar是21位的 Unicode 代码点。

        每一个UnicodeScalar拥有一个值属性，可以返回对应的21位数值，用UInt32来表示。

        for scalar in dogString.unicodeScalars {
@@ -930,6 +927,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/04_Collection_Types.html b/chapter2/04_Collection_Types.html
index 59efadb1..04527f7d 100644
--- a/chapter2/04_Collection_Types.html
+++ b/chapter2/04_Collection_Types.html
@@ -5,12 +5,12 @@
         
         
         
-        集合类型 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,21 +587,30 @@
 
                 
        
                 
-                    
        
+                    
        
                     
                         
        集合类型 (Collection Types)
        
 
        
-
        Swift语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
        
-
        Swift语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
        
+
        本页包含内容：
        
+
+
        Swift 语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
        
+
        Swift 语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift 对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
        
 
        
-
        注意：
-Swift的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见see Mutability of Collections and Assignment and Copy Behavior for Collection Types。（集合的可变性与集合在赋值和复制中的行为章节）
        
+
        注意：
        
+
        Swift 的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见集合的可变性与集合在赋值和复制中的行为章节。
        
 
        
+
        
 
        数组
        
 
        数组使用有序列表存储相同类型的多重数据。相同的值可以多次出现在一个数组的不同位置中。
        
-
        Swift数组对存储数据有具体要求。 不同于 Objective-C的NSArray和NSMutableArray类，他们可以存储任何类型的实例而且不提供他们返回对象的任何本质信息。 在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是class类型。例如： 如果我们创建了一个Int值类型的数组，我们不能往其中插入任何不是Int类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
        
+
        Swift 数组对存储数据有具体要求。 不同于 Objective-C 的NSArray和NSMutableArray类，他们可以存储任何类型的实例而且不提供他们返回对象的任何本质信息。 在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是class类型。例如： 如果我们创建了一个Int值类型的数组，我们不能往其中插入任何不是Int类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
        
+
        
 
        数组的简单语法
        
-
        写 Swift 数组应该遵循像Array<SomeType>这样的形式，其中sometype是这个数组中唯一允许存在的数据类型。 我们也可以使用像SomeType[]这样的简单语法。 尽管两种形式在功能上是一样的， 但是我们推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
        
+
        写 Swift 数组应该遵循像Array<SomeType>这样的形式，其中SomeType是这个数组中唯一允许存在的数据类型。 我们也可以使用像SomeType[]这样的简单语法。 尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
        
+
        
 
        数组构造语句
        
 
        我们可以使用字面语句来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面语句是一系列由逗号分割并由方括号包含的数值。
 [value 1, value 2, value 3]。
        
@@ -610,19 +619,20 @@ Swift的数组结构在被声明成常量和变量或者被传入函数与方法
 // shoppingList 已经被构造并且拥有两个初始项。

        • shoppingList变量被声明为“字符串值类型的数组“，记作String[]。 因为这个数组被规定只有String一种数据结构，所以只有String类型可以在其中被存取。 在这里，shoppinglist数组由两个String值（"Eggs" 和"Milk"）构造，并且由字面语句定义。

        -

        注意： -Shoppinglist数组被声明为变量（var关键字创建）而不是常量（let创建）是因为以后可能会有更多的数据项被插入其中。

        +

        注意：

        +

        Shoppinglist数组被声明为变量（var关键字创建）而不是常量（let创建）是因为以后可能会有更多的数据项被插入其中。

        在这个例子中，字面语句仅仅包含两个String值。匹配了该数组的变量声明（只能包含String的数组），所以这个字面语句的分配过程就是允许用两个初始项来构造shoppinglist。

        -

        由 于Swift 的类型推断机制，当我们用字面语句构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 shoppinglist的构造也可以这样写：

        +

        由于 Swift 的类型推断机制，当我们用字面语句构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 shoppinglist的构造也可以这样写：

        var shoppingList = ["Eggs", "Milk"]

        因为所有字面语句中的值都是相同的类型，Swift 可以推断出String[]是shoppinglist中变量的正确类型。

        +

        访问和修改数组

        我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。 还可以使用数组的只读属性count来获取数组中的数据项数量。

        println("The shopping list contains \(shoppingList.count) items.")
-// 打印出"The shopping list contains 2 items."（这个数组有2个项）
-

        使用布尔项isEmpty来作为检查count属性的值是否为0的捷径。

        +// 输出"The shopping list contains 2 items."（这个数组有2个项） +

        使用布尔项isEmpty来作为检查count属性的值是否为 0 的捷径。

        if shoppingList.isEmpty {
     println("The shopping list is empty.")
 } else {
@@ -649,14 +659,14 @@ Swift的数组结构在被声明成常量和变量或者被传入函数与方法
 
        shoppingList[4...6] = ["Bananas", "Apples"]
 // shoppingList 现在有六项
 
        
-
        注意：
-我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。除了当count等于0时（说明这是个空数组），最大索引值一直是count - 1，因为数组都是零起索引。
        
+
        注意：
        
+
        我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。除了当count等于 0 时（说明这是个空数组），最大索引值一直是count - 1，因为数组都是零起索引。
        
 
        
 
        调用数组的insert(atIndex:)方法来在某个具体索引值之前添加数据项：
        
 
        shoppingList.insert("Maple Syrup", atIndex: 0)
 // shoppingList 现在有7项
 // "Maple Syrup" 现在是这个列表中的第一项
-
        这次insert函数调用把值为"Maple Syrup"的新数据项插入shopping列表的最开始位置，并且使用0作为索引值。
        
+

        这次insert函数调用把值为"Maple Syrup"的新数据项插入列表的最开始位置，并且使用0作为索引值。

        类似的我们可以使用removeAtIndex方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）:

        let mapleSyrup = shoppingList.removeAtIndex(0)
 //索引值为0的数据项被移除
@@ -670,7 +680,8 @@ Swift的数组结构在被声明成常量和变量或者被传入函数与方法
 // 数组的最后一项被移除了
 // shoppingList现在只有5项，不包括cheese
 //  apples 常量的值现在等于"Apples" 字符串
-

        数组的遍历

        +

        +

        数组的遍历

        我们可以使用for-in循环来遍历所有数组中的数据项：

        for item in shoppingList {
     println(item)
@@ -689,7 +700,8 @@ Swift的数组结构在被声明成常量和变量或者被传入函数与方法
 // Item 3: Flour
 // Item 4: Baking Powder
 // Item 5: Bananas
-

        更多关于for-in循环的介绍请参见for循环。

        +

        更多关于for-in循环的介绍请参见for 循环。

        +

        创建并且构造一个数组

        我们可以使用构造语法来创建一个由特定数据类型构成的空数组：

        var someInts = Int[]()
@@ -710,11 +722,13 @@ someInts = []

        最后，我们可以使用加法操作符（+）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：

        var sixDoubles = threeDoubles + anotherThreeDoubles
 // sixDoubles 被推断为 Double[], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
-

        字典

        +

        +

        字典

        字典是一种存储相同类型多重数据的存储器。每个值（value）都关联独特的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

        Swift 的字典使用时需要具体规定可以存储键和值类型。不同于 Objective-C 的NSDictionary和NSMutableDictionary 类可以使用任何类型的对象来作键和值并且不提供任何关于这些对象的本质信息。在 Swift 中，在某个特定字典中可以存储的键和值必须提前定义清楚，方法是通过显性类型标注或者类型推断。

        Swift 的字典使用Dictionary<KeyType, ValueType>定义,其中KeyType是字典中键的数据类型，ValueType是字典中对应于这些键所存储值的数据类型。

        -

        KeyType的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如String，Int， Double和Bool）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见枚举）也是默认可哈希的。

        +

        KeyType的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如String，Int， Double和Bool）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见枚举）也是默认可哈希的。

        +

        字典字面语句

        我们可以使用字典字面语句来构造字典，他们和我们刚才介绍过的数组字面语句拥有相似语法。一个字典字面语句是一个定义拥有一个或者多个键值对的字典集合的简单语句。

        一个键值对是一个key和一个value的结合体。在字典字面语句中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含并且由逗号分割：

        @@ -723,19 +737,20 @@ someInts = [] 
        var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]

        airports字典被定义为一种Dictionary<String, String>,它意味着这个字典的键和值都是String类型。

        -

        注意： -airports字典被声明为变量（用var关键字）而不是常量（let关键字）因为后来更多的机场信息会被添加到这个示例字典中。

        +

        注意：

        +

        airports字典被声明为变量（用var关键字）而不是常量（let关键字）因为后来更多的机场信息会被添加到这个示例字典中。

        airports字典使用字典字面语句初始化，包含两个键值对。第一对的键是TYO，值是Tokyo。第二对的键是DUB，值是Dublin。

        这个字典语句包含了两个String: String类型的键值对。他们对应airports变量声明的类型（一个只有String键和String值的字典）所以这个字典字面语句是构造两个初始数据项的airport字典。

        和数组一样，如果我们使用字面语句构造字典就不用把类型定义清楚。airports的也可以用这种方法简短定义：

        var airports = ["TYO": "Tokyo", "DUB": "Dublin"]

        因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出Dictionary<String, String>是airports字典的正确类型。

        +

        读取和修改字典

        我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性count来获取某个字典的数据项数量：

        println("The dictionary of airports contains \(airports.count) items.")
 // 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
-

        我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的key作为下标索引，并且分配新的合适类型的值：

        +

        我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的 key 作为下标索引，并且分配新的合适类型的值：

        airports["LHR"] = "London"
 // airports 字典现在有三个数据项

        我们也可以使用下标语法来改变特定键对应的值：

        @@ -746,8 +761,8 @@ someInts = [] 
        if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") {
     println("The old value for DUB was \(oldValue).")
 }
-// 打印出 "The old value for DUB was Dublin."（dub原值是dublin）
-

        我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选 类型返回这个键存在的相关值，否则就返回nil：

        +// 输出 "The old value for DUB was Dublin."（dub原值是dublin） +

        我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选类型返回这个键存在的相关值，否则就返回nil：

        if let airportName = airports["DUB"] {
     println("The name of the airport is \(airportName).")
 } else {
@@ -765,15 +780,16 @@ airports["APL"] = nil
 } else {
     println("The airports dictionary does not contain a value for DUB.")
 }
-// 打印 "The removed airport's name is Dublin International."（被移除的机场名字是都柏林国际）
-

        字典遍历

        +// prints "The removed airport's name is Dublin International." +

        +

        字典遍历

        我们可以使用for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都由(key, value)元组形式返回，并且我们可以使用暂时性常量或者变量来分解这些元组：

        for (airportCode, airportName) in airports {
     prINTln("\(airportCode): \(airportName)")
 }
 // TYO: Tokyo
 // LHR: London Heathrow
-

        for-in循环请参见For 循环。

        +

        for-in循环请参见For 循环。

        我们也可以通过访问他的keys或者values属性（都是可遍历集合）检索一个字典的键或者值：

        for airportCode in airports.keys {
     prINTln("Airport code: \(airportCode)")
@@ -793,9 +809,10 @@ for airportName in airports.values {
 let airportNames = Array(airports.values)
 // airportNames is ["Tokyo", "London Heathrow"]
        -

        注意： -Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。

        +

        注意：

        +

        Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。

        +

        创建一个空字典

        我们可以像数组一样使用构造语法创建一个空字典：

        var namesOfIntegers = Dictionary<Int, String>()
@@ -807,17 +824,18 @@ Swift 的字典类型是无序集合类型。其中字典键，值，键值对
 namesOfIntegers = [:]
 // namesOfIntegers 又成为了一个 Int, String类型的空字典
        -

        注意： -在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见泛型。

        +

        注意：

        +

        在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见泛型。

        +

        集合的可变性

        数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。与此相反，如果我们把数组或字典分配成常量，那么他就是不可变的，它的大小不能被改变。

        对字典来说，不可变性也意味着我们不能替换其中任何现有键所对应的值。不可变字典的内容在被首次设定之后不能更改。 -不可变行对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。

        -

        Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见Assignment and Copy Behavior for Collection Types。

        +不可变行对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们·可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。

        +

        Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见集合在赋值和复制中的行为。

        -

        注意： -在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。

        +

        注意：

        +

        在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。

        @@ -864,6 +882,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/05_Control_Flow.html b/chapter2/05_Control_Flow.html index 281601be..8f214689 100644 --- a/chapter2/05_Control_Flow.html +++ b/chapter2/05_Control_Flow.html @@ -5,12 +5,12 @@ - 控制流 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
        +
        @@ -98,7 +98,7 @@

        - Swift 编程语言 + 这一次，让中国和世界同步

        @@ -119,7 +119,7 @@
      • - Introduction + 序
        • @@ -331,7 +331,7 @@
      • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,25 +587,40 @@
        -
        +
        -

        控制流

        +
        +

        翻译：vclwei, @coverxit, @NicePiao

        +

        校对：coverxit

        +
        +

        控制流

        -

        Swift提供了类似C语言的流程控制结构，包括可以多次执行任务的for和while循环，基于特定条件选择执行不同代码分支的if和switch语句，还有控制流程跳转到其他代码的break和continue语句。

        -

        除了C里面传统的 for 条件递增循环，Swift 还增加了 for-in 循环，用来更简单地遍历数组(array)，字典(dictionary)，范围（range），字符串（string）和其他序列类型。

        -

        Swift 的 switch 语句比 C 语言中更加强大。在 C 语言中，如果某个 case 不小心漏写了 break，这个 case 就会“掉入”下一个 case，Swift 无需写 break，所以不会发生这种“掉入”的情况。Case 还可以匹配更多的类型模式，包括范围（range）匹配，元组（tuple）和特定类型的描述。switch case 语句中匹配的值可以是由 case 体内部临时的常量或者变量决定，也可以由 where 分句描述更复杂的匹配条件。

        -

        For 循环

        -

        for 循环用来按照指定的次数多次执行一系列语句。Swift 提供两种 for 循环形式：

        +

        本页包含内容：

        +

        Swift提供了类似 C 语言的流程控制结构，包括可以多次执行任务的for和while循环，基于特定条件选择执行不同代码分支的if和switch语句，还有控制流程跳转到其他代码的break和continue语句。

        +

        除了 C 语言里面传统的for条件递增（for-condition-increment）循环，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分句描述更复杂的匹配条件。

        +

        +

        For 循环

        +

        for循环用来按照指定的次数多次执行一系列语句。Swift 提供两种for循环形式：

        +
          +

        • for-in用来遍历一个区间（range），序列（sequence），集合（collection），系列（progression）里面所有的元素执行一系列语句。

          +
          • +

        • for条件递增（for-condition-increment）语句，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。

          +
          • +
        +

        For-In

        -

        你可以使用 for-in 循环来遍历一个集合里面的所有元素，例如由数字表示的范围、数组中的元素、字符串中的字符。

        -

        下面的例子用来输出乘5乘法表前面一部分内容：

        -
        for index in 1...5 {
+
        你可以使用for-in循环来遍历一个集合里面的所有元素，例如由数字表示的区间、数组中的元素、字符串中的字符。
        
+
        下面的例子用来输出乘 5 乘法表前面一部分内容：
        
+
        for index in 1...5 {
     println("\(index) times 5 is \(index * 5)")
 }
 // 1 times 5 is 5
@@ -613,23 +628,26 @@
 // 3 times 5 is 15
 // 4 times 5 is 20
 // 5 times 5 is 25
-
        例子中用来进行遍历的元素是一组使用闭区间操作符(...)表示的从1到5的闭区间数字。index 被赋值为闭区间范围中的第一个数字（1），然后循环中的语句被执行一次。在本例中，这个循环只包含一个语句，用来输出当前 index 值所对应的乘5乘法表结果。该语句执行后，index 的值被更新为闭区间范围中的第二个数字（2），之后 println 方法会再执行一次。整个过程会进行到闭区间范围结尾为止。
        
-
        上面的例子中，index 是一个每次循环遍历开始时被自动赋值的常量。这种情况下，index 在使用前不需要声明，只需要将它包含在循环的声明中，就可以对其进行隐式声明，而无需使用 let 关键字声明。
        
-
        注意：
-
-index 常量只存在于循环的生命周期里。如果你想在循环完成后访问 index 的值，又或者想让 index 成为一个变量而不是常量，你必须在循环之前自己进行声明。
-
        如果你不需要知道范围内每一项的值，你可以使用下划线（_）替代变量名来忽略对值的访问：
        
-
        let base = 3
+
        
+
        例子中用来进行遍历的元素是一组使用闭区间操作符（...）表示的从1到5的数字。index被赋值为闭区间中的第一个数字（1），然后循环中的语句被执行一次。在本例中，这个循环只包含一个语句，用来输出当前index值所对应的乘 5 乘法表结果。该语句执行后，index的值被更新为闭区间中的第二个数字（2），之后println方法会再执行一次。整个过程会进行到闭区间结尾为止。
        
+
        上面的例子中，index是一个每次循环遍历开始时被自动赋值的常量。这种情况下，index在使用前不需要声明，只需要将它包含在循环的声明中，就可以对其进行隐式声明，而无需使用let关键字声明。
        
+
        
+
        注意：
        
+
        index常量只存在于循环的生命周期里。如果你想在循环完成后访问index的值，又或者想让index成为一个变量而不是常量，你必须在循环之前自己进行声明。
        
+
        
+
        如果你不需要知道区间内每一项的值，你可以使用下划线（_）替代变量名来忽略对值的访问：
        
+
        let base = 3
 let power = 10
 var answer = 1
 for _ in 1...power {
     answer *= base
 }
 println("\(base) to the power of \(power) is \(answer)")
-// prints "3 to the power of 10 is 59049
-
        这个例子计算 base 这个数的 power 次幂（本例中，是 3 的 10 次幂），从 1 （3 的 0 次幂）开始做 3 的乘法， 进行 10 次，使用 0 到 9 的半闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号 _ （替代循环中的变量）能够忽略具体的值，并且不提供循环遍历时对值的访问。
        
-
        使用 for-in 遍历一个数组所有元素：
        
-
        let names = ["Anna", "Alex", "Brian", "Jack"]
+// 输出 "3 to the power of 10 is 59049"
+
        
+
        这个例子计算 base 这个数的 power 次幂（本例中，是3的10次幂），从1（3的0次幂）开始做3的乘法， 进行10次，使用0到9的半闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号_（替代循环中的变量）能够忽略具体的值，并且不提供循环遍历时对值的访问。
        
+
        使用for-in遍历一个数组所有元素：
        
+
        let names = ["Anna", "Alex", "Brian", "Jack"]
 for name in names {
     println("Hello, \(name)!")
 }
@@ -637,17 +655,19 @@ for name in names {
 // Hello, Alex!
 // Hello, Brian!
 // Hello, Jack!
-
        你也可以通过遍历一个字典来访问它的键值对(key-value pairs)。遍历字典时，字典的每项元素会以 （key, value）元组的形式返回，你可以在 for-in 循环中使用显式的常量名称来解读 （key, value）元组。下面的例子中，字典的键(key)解读为常量 animalName ，字典的值会被解读为常量 legCount ：
        
-
        let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
+
        
+
        你也可以通过遍历一个字典来访问它的键值对（key-value pairs）。遍历字典时，字典的每项元素会以(key, value)元组的形式返回，你可以在for-in循环中使用显式的常量名称来解读(key, value)元组。下面的例子中，字典的键（key）解读为常量animalName，字典的值会被解读为常量legCount：
        
+
        let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
 for (animalName, legCount) in numberOfLegs {
     println("\(animalName)s have \(legCount) legs")
 }
 // spiders have 8 legs
 // ants have 6 legs
 // cats have 4 legs
-
        字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。更多数组和字典相关内容，查看集合类型章节。
        
-
        除了数组和字典，你也可以使用 for-in 循环来遍历字符串中的字符：
        
-
        for character in "Hello" {
+
        
+
        字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见集合类型。
        
+
        除了数组和字典，你也可以使用for-in循环来遍历字符串中的字符（Character）：
        
+
        for character in "Hello" {
     println(character)
 }
 // H
@@ -655,33 +675,39 @@ for (animalName, legCount) in numberOfLegs {
 // l
 // l
 // o
-
        For条件递增（for-condition-increment）
        
-
        除了 for-in 循环，Swift 提供使用条件判断和递增方法的标准C样式 for 循环:
        
-
        for var index = 0; index < 3; ++index {
+
        
+
        
+
        For条件递增（for-condition-increment）
        
+
        除了for-in循环，Swift 提供使用条件判断和递增方法的标准 C 样式for循环:
        
+
        for var index = 0; index < 3; ++index {
     println("index is \(index)")
 }
 // index is 0
 // index is 1
 // index is 2
-
        下面是一般情况下这种循环方式的格式：
        
-
        for initialization; condition; increment {
-    statements
+
        
+
        下面是一般情况下这种循环方式的格式：
        
+
        for `initialization`; `condition`; `increment` {
+    `statements`
 }
-
        和 C 语言中一样，分号将循环的定义分为 3 个部分，不同的是，Swift 不需要使用圆括号将“initialization; condition; increment”包括起来。
        
+
        +

        和 C 语言中一样，分号将循环的定义分为 3 个部分，不同的是，Swift 不需要使用圆括号将“initialization; condition; increment”包括起来。

        这个循环执行流程如下：

        1. 循环首次启动时，初始化表达式（initialization expression）被调用一次，用来初始化循环所需的所有常量和变量。
          2. -
        2. 条件表达式（condition expression）被调用，如果表达式调用结果为 false，循环结束，继续执行 for 循环关闭大括号(})之后的代码。如果表达式调用结果为 true，则会执行大括号内部的代码（statements）。
          3. -
        3. 执行所有语句（statements）之后，执行递增表达式（increment expression）。通常会增加或减少计数器的值，或者根据语句（statements）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第2步，条件表达式会再次执行。
          4. +
        4. 条件表达式（condition expression）被调用，如果表达式调用结果为false，循环结束，继续执行for循环关闭大括号 +（}）之后的代码。如果表达式调用结果为true，则会执行大括号内部的代码（statements）。
          5. +
        5. 执行所有语句（statements）之后，执行递增表达式（increment expression）。通常会增加或减少计数器的值，或者根据语句（statements）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 2 步，条件表达式会再次执行。

        上述描述和循环格式等同于：

        -
        initialization
-while condition {
-    statements
-    increment
+
        `initialization`
+while `condition` {
+    `statements`
+    `increment`
 }
-
        在初始化表达式中声明的常量和变量(比如 var index = 0)只在 for 循环的生命周期里有效。如果想在循环结束后访问 index 的值，你必须要在循环生命周期开始前声明 index。
        
-
        var index: Int
+
        
+
        在初始化表达式中声明的常量和变量（比如var index = 0）只在for循环的生命周期里有效。如果想在循环结束后访问index的值，你必须要在循环生命周期开始前声明index。
        
+
        var index: Int
 for index = 0; index < 3; ++index {
     println("index is \(index)")
 }
@@ -689,107 +715,118 @@ for index = 0; index < 3; ++index {
 // index is 1
 // index is 2
 println("The loop statements were executed \(index) times")
-// prints "The loop statements were executed 3 times
-
        注意 index 在循环结束后最终的值是 3 而不是 2。最后一次调用递增表达式 ++index 会将 index 设置为 3，从而导致 index < 3 条件为 false，并终止循环。
        
+// 输出 "The loop statements were executed 3 times
+
        +

        注意index在循环结束后最终的值是3而不是2。最后一次调用递增表达式++index会将index设置为3，从而导致index < 3条件为false，并终止循环。

        +

        While 循环

        -

        While 循环运行一系列语句直到条件变成 false。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种 while 循环形式：

        +

        while循环运行一系列语句直到条件变成false。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种while循环形式：

          -

        • while 循环，每次在循环开始时计算条件是否符合；

          +

        • while循环，每次在循环开始时计算条件是否符合；

          • -

        • do-while 循环，每次在循环结束时计算条件是否符合。

          +

        • do-while循环，每次在循环结束时计算条件是否符合。

        +

        While

        -

        While 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为false。

        +

        while循环从计算单一条件开始。如果条件为true，会重复运行一系列语句，直到条件变为false。

        下面是一般情况下 while 循环格式：

        -
        while condition {
-    statements
+
        while `condition` {
+    `statements`
 }
-
        下面的例子来玩一个叫做 蛇和梯子 的小游戏（也叫做 滑道和梯子 ）:
        
+
        +

        下面的例子来玩一个叫做蛇和梯子（Snakes and Ladders）的小游戏，也叫做滑道和梯子（Chutes and Ladders）：

        image

        游戏的规则如下：

        • 游戏盘面包括 25 个方格，游戏目标是达到或者超过第 25 个方格；
          • -
        • 每一轮，你通过掷一个6边的骰子来确定你移动方块的步数，移动的路线由上图中横向的虚线所示；
          • +
        • 每一轮，你通过掷一个 6 边的骰子来确定你移动方块的步数，移动的路线由上图中横向的虚线所示；
        • 如果在某轮结束，你移动到了梯子的底部，可以顺着梯子爬上去；
        • 如果在某轮结束，你移动到了蛇的头部，你会顺着蛇的身体滑下去。
        -

        游戏盘面可以使用一个 Int 数组来表达。数组的长度由一个 finalSquare 常量储存，用来初始化数组和检测最终胜利条件。游戏盘面由 26 个 Int 0 值初始化，而不是 25个 （由 0 到 25，一共 26 个）：

        -
        let finalSquare = 25
+
        游戏盘面可以使用一个Int数组来表达。数组的长度由一个finalSquare常量储存，用来初始化数组和检测最终胜利条件。游戏盘面由 26 个 Int 0 值初始化，而不是 25 个（由0到25，一共 26 个）：
        
+
        let finalSquare = 25
 var board = Int[](count: finalSquare + 1, repeatedValue: 0)
-
        一些方块被设置成有蛇或者梯子的指定值。梯子底部的方块是一个正值，是你可以向上移动，蛇头处的方块是一个负值，会让你向下移动：
        
-
        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
+
        
+
        一些方块被设置成有蛇或者梯子的指定值。梯子底部的方块是一个正值，使你可以向上移动，蛇头处的方块是一个负值，会让你向下移动：
        
+
        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
-
        3 号方块是梯子的底部，会让你向上移动到 11 号方格，我们使用 board[03] 等于 +08 来表示（11 和 3 之间的差值）。使用一元加运算符（+i）是为了和一元减运算符（-i）对称，为了让盘面代码整齐，小于 10 的数字都使用 0 补齐（这些风格上的调整都不是必须的，只是为了让代码看起来更加整洁）。
        
+
        +

        3 号方块是梯子的底部，会让你向上移动到 11 号方格，我们使用board[03]等于+08（来表示11和3之间的差值）。使用一元加运算符（+i）是为了和一元减运算符（-i）对称，为了让盘面代码整齐，小于 10 的数字都使用 0 补齐（这些风格上的调整都不是必须的，只是为了让代码看起来更加整洁）。

        玩家由左下角编号为 0 的方格开始游戏。一般来说玩家第一次掷骰子后才会进入游戏盘面：

        -
        var square = 0
+
        var square = 0
 var diceRoll = 0
 while square < finalSquare {
-    // roll the dice
+    // 掷骰子
     if ++diceRoll == 7 { diceRoll = 1 }
-    // move by the rolled amount
+    // 根据点数移动
     square += diceRoll
     if square < board.count {
-        // if we're still on the board, move up or down for a snake or a ladder
+        // 如果玩家还在棋盘上，顺着梯子爬上去或者顺着蛇滑下去
         square += board[square]
     }
 }
 println("Game over!")
-
        本例中使用了最简单的方法来模拟掷骰子。 diceRoll 的值并不是一个随机数，而是以 0 为初始值，之后每一次 while 循环，diceRoll 的值使用前置自增操作符(++i)来自增 1 ，然后检测是否超出了最大值。++diceRoll 调用完成后，返回值等于 diceRoll 自增后的值。任何时候如果 diceRoll 的值等于7时，就超过了骰子的最大值，会被重置为 1。所以 diceRoll 的取值顺序会一直是 1, 2, 3, 4, 5, 6, 1, 2。
        
-
        掷完骰子后，玩家向前移动 diceRoll 个方格，如果玩家移动超过了第 25 个方格，这个时候游戏结束，相应的，代码会在 square 增加 board[square] 的值向前或向后移动（遇到了梯子或者蛇）之前，检测 square 的值是否小于 board 的 count 属性。
        
-
        如果没有这个检测（square < board.count），board[square] 可能会越界访问 board 数组，导致错误。例如如果 square 等于 26， 代码会去尝试访问 board[26]，超过数组的长度。
        
-
        当本轮 while 循环运行完毕，会再检测循环条件是否需要再运行一次循环。如果玩家移动到或者超过第 25 个方格，循环条件结果为 false，此时游戏结束。
        
+
        +

        本例中使用了最简单的方法来模拟掷骰子。 diceRoll的值并不是一个随机数，而是以0为初始值，之后每一次while循环，diceRoll的值使用前置自增操作符(++i)来自增 1 ，然后检测是否超出了最大值。++diceRoll调用完成后，返回值等于diceRoll自增后的值。任何时候如果diceRoll的值等于7时，就超过了骰子的最大值，会被重置为1。所以diceRoll的取值顺序会一直是1，2，3，4，5，6，1，2。

        +

        掷完骰子后，玩家向前移动diceRoll个方格，如果玩家移动超过了第 25 个方格，这个时候游戏结束，相应地，代码会在square增加board[square]的值向前或向后移动（遇到了梯子或者蛇）之前，检测square的值是否小于board的count属性。

        +

        如果没有这个检测（square < board.count），board[square]可能会越界访问board数组，导致错误。例如如果square等于26， 代码会去尝试访问board[26]，超过数组的长度。

        +

        当本轮while循环运行完毕，会再检测循环条件是否需要再运行一次循环。如果玩家移动到或者超过第 25 个方格，循环条件结果为false，此时游戏结束。

        while 循环比较适合本例中的这种情况，因为在 while 循环开始时，我们并不知道游戏的长度或者循环的次数，只有在达成指定条件时循环才会结束。

        +

        Do-While

        -

        while 循环的另外一种形式是 do-while，它和 while 的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为 false。

        -

        下面是一般情况下 do-while 循环的格式：

        -
        do {
-    statements
-} while condition
-

        还是蛇和梯子的游戏，使用 do-while 循环来替代 while 循环。finalSquare，board，square 和 diceRoll 的值初始化同 while 循环一样：

        -
        let finalSquare = 25
+
        while循环的另外一种形式是do-while，它和while的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为false。
        
+
        下面是一般情况下 do-while循环的格式：
        
+
        do {
+    `statements`
+} while `condition`
+
        
+
        还是蛇和梯子的游戏，使用do-while循环来替代while循环。finalSquare、board、square和diceRoll的值初始化同while循环一样：
        
+
        let finalSquare = 25
 var board = Int[](count: finalSquare + 1, repeatedValue: 0)
 board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
 var square = 0
 var diceRoll = 0
-
        do-while 的循环版本，循环中第一步就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
        
-
        游戏开始时，玩家在第 0 个方格上，board[0] 一直等于 0， 不会有什么影响：
        
-
        do {
-    // move up or down for a snake or ladder
+
        
+
        do-while的循环版本，循环中第一步就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
        
+
        游戏开始时，玩家在第 0 个方格上，board[0]一直等于 0， 不会有什么影响：
        
+
        do {
+    // 顺着梯子爬上去或者顺着蛇滑下去
     square += board[square]
-    // roll the dice
+    // 掷骰子
     if ++diceRoll == 7 { diceRoll = 1 }
-    // move by the rolled amount
+    // 根据点数移动
     square += diceRoll
 } while square < finalSquare
 println("Game over!")
-
        检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动 diceRoll 个方格，本轮循环结束。
        
-
        循环条件（while square < finalSquare）和 while 方式相同，但是只会在循环结束后进行计算。在这个游戏中，do-while 表现得比 while 循环更好。 do-while 方式会在条件判断 square 没有超出后直接运行 square += board[square] ，这种方式可以去掉 while 版本中的数组越界判断。
        
+
        +

        检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动diceRoll个方格，本轮循环结束。

        +

        循环条件（while square < finalSquare）和while方式相同，但是只会在循环结束后进行计算。在这个游戏中，do-while表现得比while循环更好。do-while方式会在条件判断square没有超出后直接运行square += board[square]，这种方式可以去掉while版本中的数组越界判断。

        条件语句

        根据特定的条件执行特定的代码通常是十分有用的，例如：当错误发生时，你可能想运行额外的代码；或者，当输入的值太大或太小时，向用户显示一条消息等。要实现这些功能，你就需要使用条件语句。

        -

        Swift 提供两种类型的条件语句：if语句和switch语句。通常，当条件较为简单且可能的情况很少时，使用if语句。而switch语句更适用于复杂的条件、可能的情况很多且需要用到模式匹配(pattern-matching)的情境。

        +

        Swift 提供两种类型的条件语句：if语句和switch语句。通常，当条件较为简单且可能的情况很少时，使用if语句。而switch语句更适用于条件较复杂、可能情况较多且需要用到模式匹配（pattern-matching）的情境。

        If

        -

        if语句最简单的形式就是只包含一个条件，当且仅当该条件为真时，才执行相关代码：

        +

        if语句最简单的形式就是只包含一个条件，当且仅当该条件为true时，才执行相关代码：

        var temperatureInFahrenheit = 30
 if temperatureInFahrenheit <= 32 {
     println("It's very cold. Consider wearing a scarf.")
 }
-// prints "It's very cold. Consider wearing a scarf."
+// 输出 "It's very cold. Consider wearing a scarf."
        -

        上面的例子会判断温度是否小于等于32华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行if块后面的代码。

        -

        当然，if语句允许二选一，也就是当条件为假时，执行else语句：

        +

        上面的例子会判断温度是否小于等于 32 华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行if块后面的代码。

        +

        当然，if语句允许二选一，也就是当条件为false时，执行 else 语句：

        temperatureInFahrenheit = 40
 if temperatureInFahrenheit <= 32 {
     println("It's very cold. Consider wearing a scarf.")
 } else {
     println("It's not that cold. Wear a t-shirt.")
 }
-// prints "It's not that cold. Wear a t-shirt."
+// 输出 "It's not that cold. Wear a t-shirt."
        -

        显然，这两条分支中总有一条会被执行。由于温度已升至40华氏度，不算太冷，没必要再围围巾——因此，else分支就被触发了。

        +

        显然，这两条分支中总有一条会被执行。由于温度已升至 40 华氏度，不算太冷，没必要再围围巾——因此，else分支就被触发了。

        你可以把多个if语句链接在一起，像下面这样：

        temperatureInFahrenheit = 90
 if temperatureInFahrenheit <= 32 {
@@ -799,10 +836,10 @@ if temperatureInFahrenheit <= 32 {
 } else {
     println("It's not that cold. Wear a t-shirt.")
 }
-// prints "It's really warm. Don't forget to wear sunscreen."
+// 输出 "It's really warm. Don't forget to wear sunscreen."
        -

        在上面的例子中，额外的if语句用于判断是不是特别热。而最后的else语句被保留了下来，用于打印既不冷也不热时的消息。

        -

        实际上，最后的else语句是可选的：

        +

        在上面的例子中，额外的if语句用于判断是不是特别热。而最后的else语句被保留了下来，用于打印既不冷也不热时的消息。

        +

        实际上，最后的else语句是可选的：

        temperatureInFahrenheit = 72
 if temperatureInFahrenheit <= 32 {
     println("It's very cold. Consider wearing a scarf.")
@@ -813,7 +850,7 @@ if temperatureInFahrenheit <= 32 {
 
        在这个例子中，由于既不冷也不热，所以不会触发if或else if分支，也就不会打印任何消息。
        
 
        
 
        Switch
        
-
        switch语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式，switch语句会执行对应的代码。当有可能的情况较多时，通常用switch语句替换if语句。
        
+
        switch语句会尝试把某个值与若干个模式（pattern）进行匹配。根据第一个匹配成功的模式，switch语句会执行对应的代码。当有可能的情况较多时，通常用switch语句替换if语句。
        
 
        switch语句最简单的形式就是把某个值与一个或若干个相同类型的值作比较：
        
 
        switch `some value to consider` {
 case `value 1`:
@@ -825,9 +862,9 @@ default:
     `otherwise, do something else`
 }
 
        
-
        switch语句都由多个case构成。为了匹配某些更特定的值，Swift 提供了几种更复杂的匹配模式，这些模式将在本节的稍后部分提到。
        
-
        每一个case都是代码执行的一条分支，这与if语句类似。与之不同的是，switch语句会决定哪一条分支应该被执行。
        
-
        switch语句必须是完备的。这就是说，每一个可能的值都必须至少有一个case块与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认(default)块满足该要求，这个默认块必须在switch语句的最后面。
        
+
        switch语句都由多个 case 构成。为了匹配某些更特定的值，Swift 提供了几种更复杂的匹配模式，这些模式将在本节的稍后部分提到。
        
+
        每一个 case 都是代码执行的一条分支，这与if语句类似。与之不同的是，switch语句会决定哪一条分支应该被执行。
        
+
        switch语句必须是完备的。这就是说，每一个可能的值都必须至少有一个 case 分支与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认（default）分支满足该要求，这个默认分支必须在switch语句的最后面。
        
 
        下面的例子使用switch语句来匹配一个名为someCharacter的小写字符：
        
 
        let someCharacter: Character = "e"
 switch someCharacter {
@@ -839,16 +876,18 @@ case "b", "c", "d", "f", "g",
 default:
     println("\(someCharacter) is not a vowel or a consonant")
 }
-// prints "e is a vowel"
+// 输出 "e is a vowel"
 
        
-
        在这个例子中，第一个case块用于匹配五个元音，第二个case块用于匹配所有的辅音。
        
-
        由于为其它可能的字符写case快没有实际的意义，因此在这个例子中使用了默认块来处理剩下的既不是元音也不是辅音的字符——这就保证了switch语句的完备性。
        
-
        不存在隐式的贯穿(Fallthrough)
        
-
        与C语言和Objective-C中的switch语句不同，在 Swift 中，当匹配的case块中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个case块。这也就是说，不需要在case块中显式地使用break语句。这使得switch语句更安全、更易用，也避免了因忘记写break语句而产生的错误。
        
+
        在这个例子中，第一个 case 分支用于匹配五个元音，第二个 case 分支用于匹配所有的辅音。
        
+
        由于为其它可能的字符写 case 分支没有实际的意义，因此在这个例子中使用了默认分支来处理剩下的既不是元音也不是辅音的字符——这就保证了switch语句的完备性。
        
+
        
+
        不存在隐式的贯穿（No Implicit Fallthrough）
        
+
        与 C 语言和 Objective-C 中的switch语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止switch语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用break语句。这使得switch语句更安全、更易用，也避免了因忘记写break语句而产生的错误。
        
 
        
-
        注意：你依然可以在case块中的代码执行完毕前跳出，详情请参考Switch 语句中的 Break待添加链接
        
+
        注意：
        
+
        你依然可以在 case 分支中的代码执行完毕前跳出，详情请参考Switch 语句中的 break。
        
 
        
-
        每一个case块都必须包含至少一条语句。像下面这样书写代码是无效的，因为第一个case块是空的：
        
+
        每一个 case 分支都必须包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的：
        
 
        let anotherCharacter: Character = "a"
 switch anotherCharacter {
 case "a":
@@ -859,8 +898,8 @@ default:
 }
 // this will report a compile-time error
 
        
-
        不像C语言里的switch语句，在 Swift 中，switch语句不会同时匹配"a"和"A"。相反的，上面的代码会引起编译期错误：case "a": does not contain any executable statements——这就避免了意外地从一个case块贯穿到另外一个，使得代码更安全、也更直观。
        
-
        一个case也可以包含多个模式，用逗号把它们分开（如果太长了也可以分行写）：
        
+
        不像 C 语言里的switch语句，在 Swift 中，switch语句不会同时匹配"a"和"A"。相反的，上面的代码会引起编译期错误：case "a": does not contain any executable statements——这就避免了意外地从一个 case 分支贯穿到另外一个，使得代码更安全、也更直观。
        
+
        一个 case 也可以包含多个模式，用逗号把它们分开（如果太长了也可以分行写）：
        
 
        switch `some value to consider` {
 case `value 1`,
 `value 2`:
@@ -868,10 +907,12 @@ case `value 1`,
 }
 
        
 
        
-
        注意：如果想要贯穿特定的case块中，请使用fallthrough语句，详情请参考贯穿 (Fallthrough)待添加链接
        
+
        注意：
+如果想要贯穿至特定的 case 分支中，请使用fallthrough语句，详情请参考贯穿（Fallthrough）。
        
 
        
-
        范围匹配
        
-
        case块的模式也可以是一个值的范围。下面的例子展示了如何使用范围匹配来输出任意数字对应的自然语言格式：
        
+
        
+
        区间匹配（Range Matching）
        
+
        case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格式：
        
 
        let count = 3_000_000_000_000
 let countedThings = "stars in the Milky Way"
 var naturalCount: String
@@ -892,10 +933,11 @@ default:
     naturalCount = "millions and millions of"
 }
 println("There are \(naturalCount) \(countedThings).")
-// prints "There are millions and millions of stars in the Milky Way."
+// 输出 "There are millions and millions of stars in the Milky Way."
 
        
-
        元组 (Tuple)
        
-
        你可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是范围。另外，使用下划线(_)来匹配所有可能的值。
        
+
        
+
        元组（Tuple）
        
+
        你可以使用元组在同一个switch语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（_）来匹配所有可能的值。
        
 
        下面的例子展示了如何使用一个(Int, Int)类型的元组来分类下图中的点(x, y)：
        
 
        let somePoint = (1, 1)
 switch somePoint {
@@ -910,13 +952,14 @@ case (-2...2, -2...2):
 default:
     println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
 }
-// prints "(1, 1) is inside the box"
+// 输出 "(1, 1) is inside the box"
 
        
-
        
+
        image
        
 
        在上面的例子中，switch语句会判断某个点是否是原点(0, 0)，是否在红色的x轴上，是否在黄色y轴上，是否在一个以原点为中心的4x4的矩形里，或者在这个矩形外面。
        
-
        不像C语言，Swift 允许多个case匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有四个case。但是，如果存在多个匹配，那么只会执行第一个被匹配到的case块。考虑点(0, 0)会首先匹配case (0, 0)，因此剩下的能够匹配(0, 0)的case块都会被忽视掉。
        
-
        值绑定 (Value Bindings)
        
-
        case块的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该case块里就可以被引用了——这种行为被称为值绑定。
        
+
        不像 C 语言，Swift 允许多个 case 匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有四个 case。但是，如果存在多个匹配，那么只会执行第一个被匹配到的 case 分支。考虑点(0, 0)会首先匹配case (0, 0)，因此剩下的能够匹配(0, 0)的 case 分支都会被忽视掉。
        
+
        
+
        值绑定（Value Bindings）
        
+
        case 分支的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该 case 分支里就可以被引用了——这种行为被称为值绑定（value binding）。
        
 
        下面的例子展示了如何在一个(Int, Int)类型的元组中使用值绑定来分类下图中的点(x, y)：
        
 
        let anotherPoint = (2, 0)
 switch anotherPoint {
@@ -927,16 +970,17 @@ case (0, let y):
 case let (x, y):
     println("somewhere else at (\(x), \(y))")
 }
-// prints "on the x-axis with an x value of 2"
+// 输出 "on the x-axis with an x value of 2"
 
        
-
        
+
        image
        
 
        在上面的例子中，switch语句会判断某个点是否在红色的x轴上，是否在黄色y轴上，或者不在坐标轴上。
        
-
        这三个case都声明了常量x和y的占位符，用于临时获取元组anotherPoint的一个或两个值。第一个case——case (let x, 0)将匹配一个纵坐标为0的点，并把这个点的横坐标赋给临时的常量x。类似的，第二个case——case (0, let y)将匹配一个横坐标为0的点，并把这个点的纵坐标赋给临时的常量y。
        
-
        一旦声明了这些临时的常量，它们就可以在其对应的case块里引用。在这个例子中，它们用于简化println的书写。
        
-
        请注意，这个switch语句不包含默认块。这是因为最后一个case——case let(x, y)声明了一个可以匹配余下所有值的元组。这使得switch语句已经完备了，因此不需要再书写默认块。
        
-
        在上面的例子中，x和y是常量，这是因为没有必要在其对应的case块中修改它们的值。然而，它们也可以是变量——程序将会创建临时变量，并用相应的值初始化它。修改这些变量只会影响其对应的case块。
        
+
        这三个 case 都声明了常量x和y的占位符，用于临时获取元组anotherPoint的一个或两个值。第一个 case ——case (let x, 0)将匹配一个纵坐标为0的点，并把这个点的横坐标赋给临时的常量x。类似的，第二个 case ——case (0, let y)将匹配一个横坐标为0的点，并把这个点的纵坐标赋给临时的常量y。
        
+
        一旦声明了这些临时的常量，它们就可以在其对应的 case 分支里引用。在这个例子中，它们用于简化println的书写。
        
+
        请注意，这个switch语句不包含默认分支。这是因为最后一个 case ——case let(x, y)声明了一个可以匹配余下所有值的元组。这使得switch语句已经完备了，因此不需要再书写默认分支。
        
+
        在上面的例子中，x和y是常量，这是因为没有必要在其对应的 case 分支中修改它们的值。然而，它们也可以是变量——程序将会创建临时变量，并用相应的值初始化它。修改这些变量只会影响其对应的 case 分支。
        
+
        
 
        Where
        
-
        case块的模式可以使用where语句来判断额外的条件。
        
+
        case 分支的模式可以使用where语句来判断额外的条件。
        
 
        下面的例子把下图中的点(x, y)进行了分类：
        
 
        let yetAnotherPoint = (1, -1)
 switch yetAnotherPoint {
@@ -947,13 +991,14 @@ case let (x, y) where x == -y:
 case let (x, y):
     println("(\(x), \(y)) is just some arbitrary point")
 }
-// prints "(1, -1) is on the line x == -y"
+// 输出 "(1, -1) is on the line x == -y"
 
        
-
        
+
        image
        
 
        在上面的例子中，switch语句会判断某个点是否在绿色的对角线x == y上，是否在紫色的对角线x == -y上，或者不在对角线上。
        
-
        这三个case都声明了常量x和y的占位符，用于临时获取元组yetAnotherPoint的两个值。这些常量被用作where语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当where语句的条件为真时，匹配到的case块才会被执行。
        
-
        就像是值绑定中的例子，由于最后一个case块匹配了余下所有可能的值，switch语句就已经完备了，因此不需要再书写默认块。
        
-
        控制转移语句
        
+
        这三个 case 都声明了常量x和y的占位符，用于临时获取元组yetAnotherPoint的两个值。这些常量被用作where语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当where语句的条件为true时，匹配到的 case 分支才会被执行。
        
+
        就像是值绑定中的例子，由于最后一个 case 分支匹配了余下所有可能的值，switch语句就已经完备了，因此不需要再书写默认分支。
        
+
        
+
        控制传递语句（Control Transfer Statements）
        
 
        控制转移语句改变你代码的执行顺序，通过它你可以实现代码的跳转。Swift有四种控制转移语句。
        
 
          
 
        • continue
          • 
@@ -961,49 +1006,54 @@ case let (x, y):
 
        • fallthrough
          • 
 
        • return
          • 
 
        
-
        我们将会在下面讨论continue ,break,和fallthrough语句。return语句将会在函数章节讨论。
        
+
        我们将会在下面讨论continue、break和fallthrough语句。return语句将会在函数章节讨论。
        
+
        
 
        Continue
        
-
        continue告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。就好像在说“本次循环迭代我已经执行完了”，但是并不会离开整个循环体。
        
+
        continue语句告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。就好像在说“本次循环迭代我已经执行完了”，但是并不会离开整个循环体。
        
 
        
-
        NOTE
-在一个for-condition-increment循环体中，在调用continue语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
        
+
        注意：
        
+
        在一个for条件递增（for-condition-increment）循环体中，在调用continue语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
        
 
        
 
        下面的例子把一个小写字符串中的元音字母和空格字符移除，生成了一个含义模糊的短句：
        
-
        let puzzleInput = "great minds think alike"
+
        let puzzleInput = "great minds think alike"
 var puzzleOutput = ""
 for character in puzzleInput {
     switch character {
     case "a", "e", "i", "o", "u", " ":
         continue
     default:
-    puzzleOutput += character
+        puzzleOutput += character
     }
 }
 println(puzzleOutput)
-// prints "grtmndsthnklk"
-
        在上面的代码中，只要匹配到元音字母或者空格字符，就调用continue语句，使本次循环迭代结束，从新开始下次循环迭代。这种行为使switch匹配到元音字母和空格字符时不做处理，而不是让每一个匹配到的字符都被打印。
        
+    // 输出 "grtmndsthnklk"
+
        
+
        在上面的代码中，只要匹配到元音字母或者空格字符，就调用continue语句，使本次循环迭代结束，从新开始下次循环迭代。这种行为使switch匹配到元音字母和空格字符时不做处理，而不是让每一个匹配到的字符都被打印。
        
+
        
 
        Break
        
 
        break语句会立刻结束整个控制流的执行。当你想要更早的结束一个switch代码块或者一个循环体时，你都可以使用break语句。
        
-
        在循环体中使用Break
        
-
        当在一个循环体中使用break时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(})后的第一行代码。不会再有本次循环迭代的代码被执行，也不会再有下次的循环迭代产生。
        
-
        在Switch代码块中使用Break
        
-
        当在一个switch代码块中使用break时，会立即中断该switch代码块的执行，并且跳转到表示switch代码块结束的大括号(})后的第一行代码。
        
-
        这种特性可以被用来匹配或者忽略一个或多个分支。因为Swift语言的switch需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上break语句。当那个分支被匹配到时，分支内的break语句立即结束switch代码块。
        
+
        
+
        循环语句中的 break
        
+
        当在一个循环体中使用break时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(})后的第一行代码。不会再有本次循环迭代的代码被执行，也不会再有下次的循环迭代产生。
        
+
        
+
        Switch 语句中的 break
        
+
        当在一个switch代码块中使用break时，会立即中断该switch代码块的执行，并且跳转到表示switch代码块结束的大括号(})后的第一行代码。
        
+
        这种特性可以被用来匹配或者忽略一个或多个分支。因为 Swift 的switch需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上break语句。当那个分支被匹配到时，分支内的break语句立即结束switch代码块。
        
 
        
-
        NOTE
-当一个switch分支仅仅包含注释时，会被报编译时错误。注释不是代码语句而且也不能让switch分支达到被忽略的效果。你总是可以使用break来忽略某个分支。
        
+
        注意：
        
+
        当一个switch分支仅仅包含注释时，会被报编译时错误。注释不是代码语句而且也不能让switch分支达到被忽略的效果。你总是可以使用break来忽略某个分支。
        
 
        
 
        下面的例子通过switch来判断一个Character值是否代表下面四种语言之一。为了简洁，多个值被包含在了同一个分支情况中。
        
-
        let numberSymbol: Character = "三"  // Simplified Chinese for the number 3
-possibleIntegerValue: Int?
+
        let numberSymbol: Character = "三"  // 简体中文里的数字 3
+var possibleIntegerValue: Int?
 switch numberSymbol {
-case "1", "?", "一", "?":
+case "1", "١", "一", "๑":
     possibleIntegerValue = 1
-case "2", "?", "二", "?":
+case "2", "٢", "二", "๒":
     possibleIntegerValue = 2
-case "3", "?", "三", "?":
+case "3", "٣", "三", "๓":
     possibleIntegerValue = 3
-case "4", "?", "四", "?":
+case "4", "٤", "四", "๔":
     possibleIntegerValue = 4
 default:
     break
@@ -1013,14 +1063,16 @@ if let integerValue = possibleIntegerValue {
 } else {
     println("An integer value could not be found for \(numberSymbol).")
 }
-// prints "The integer value of 三 is 3."
-
        这个例子检查numberSymbol是否是拉丁，阿拉伯，中文或者泰语中的1...4之一。如果被匹配到，该switch分支语句给Int?类型变量possibleIntegerValue设置一个整数值。
        
-
        当switch代码块执行完后，接下来的代码通过使用可选绑定来判断'possibleIntegerValue'是否曾经被设置过值。因为是可选类型的缘故，'possibleIntegerValue'有一个隐式的初始值nil，所以仅仅当possibleIntegerValue曾被switch代码块的前四个分支中的某个设置过一个值时，可选的绑定将会被判定为成功。
        
-
        在上面的例子中，想要把Character所有的的可能性都枚举出来是不现实的，所以使用default分支来包含所有上面没有匹配到字符的情况。由于这个default分支不需要执行任何动作，所以它只写了一条break语句。一旦落入到default分支中后，break语句就完成了该分支的所有代码操作，代码继续向下,开始执行if let语句。
        
-
        Fallthrough
        
-
        Swift语言中的switch不会从上一个case分支落入到下一个case分支中。相反，只要第一个匹配到的case分支完成了它需要执行的语句，整个switch代码块完成了它的执行。相比之下，C语言要求你显示的插入break语句到每个switch分支的末尾来阻止自动落入到下一个case分支中。Swift语言的这种避免默认落入到下一个分支中的特性意味着它的switch 功能要比C语言的更加清晰和可预测，可以避免无意识地执行多个case分支从而引发的错误。
        
-
        如果你确实需要C风格的落入(fallthrough)的特性，你可以在每个需要该特性的case分支中使用fallthrough关键字。下面的例子使用fallthrough来创建一个数字的描述语句。
        
-
        let integerToDescribe = 5
+// 输出 "The integer value of 三 is 3."
+
        
+
        这个例子检查numberSymbol是否是拉丁，阿拉伯，中文或者泰语中的1到4之一。如果被匹配到，该switch分支语句给Int?类型变量possibleIntegerValue设置一个整数值。
        
+
        当switch代码块执行完后，接下来的代码通过使用可选绑定来判断possibleIntegerValue是否曾经被设置过值。因为是可选类型的缘故，possibleIntegerValue有一个隐式的初始值nil，所以仅仅当possibleIntegerValue曾被switch代码块的前四个分支中的某个设置过一个值时，可选的绑定将会被判定为成功。
        
+
        在上面的例子中，想要把Character所有的的可能性都枚举出来是不现实的，所以使用default分支来包含所有上面没有匹配到字符的情况。由于这个default分支不需要执行任何动作，所以它只写了一条break语句。一旦落入到default分支中后，break语句就完成了该分支的所有代码操作，代码继续向下，开始执行if let语句。
        
+
        
+
        贯穿（Fallthrough）
        
+
        Swift 中的switch不会从上一个 case 分支落入到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个switch代码块完成了它的执行。相比之下，C 语言要求你显示的插入break语句到每个switch分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的switch 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。
        
+
        如果你确实需要 C 风格的贯穿（fallthrough）的特性，你可以在每个需要该特性的 case 分支中使用fallthrough关键字。下面的例子使用fallthrough来创建一个数字的描述语句。
        
+
        let integerToDescribe = 5
 var description = "The number \(integerToDescribe) is"
 switch integerToDescribe {
 case 2, 3, 5, 7, 11, 13, 17, 19:
@@ -1030,54 +1082,58 @@ default:
     description += " an integer."
 }
 println(description)
-// prints "The number 5 is a prime number, and also an integer."
-
        这个例子定义了一个String类型的变量description并且给它设置了一个初始值。函数使用switch逻辑来判断integerToDescribe变量的值。当integerToDescribe的值属于列表中的质数之一时，该函数添加一段文字在description后，来表明这个是数字是一个质数。然后它使用fallthrough关键字来"落入"到default分支中。default分支添加一段额外的文字在description的最后,至此switch代码块执行完了。
        
+// 输出 "The number 5 is a prime number, and also an integer."
+
        
+
        这个例子定义了一个String类型的变量description并且给它设置了一个初始值。函数使用switch逻辑来判断integerToDescribe变量的值。当integerToDescribe的值属于列表中的质数之一时，该函数添加一段文字在description后，来表明这个是数字是一个质数。然后它使用fallthrough关键字来“贯穿”到default分支中。default分支添加一段额外的文字在description的最后，至此switch代码块执行完了。
        
 
        如果integerToDescribe的值不属于列表中的任何质数，那么它不会匹配到第一个switch分支。而这里没有其他特别的分支情况，所以integerToDescribe匹配到包含所有的default分支中。
        
 
        当switch代码块执行完后，使用println函数打印该数字的描述。在这个例子中，数字5被准确的识别为了一个质数。
        
 
        
-
        NOTE
-fallthrough关键字不会检查它下一个将会落入执行的case中的匹配条件。fallthrough简单地使代码执行继续连接到下一个case中的执行代码，这和C语言标准中的switch语句特性是一样的。
        
+
        注意：
        
+
        fallthrough关键字不会检查它下一个将会落入执行的 case 中的匹配条件。fallthrough简单地使代码执行继续连接到下一个 case 中的执行代码，这和 C 语言标准中的switch语句特性是一样的。
        
 
        
-
        Labeled Statements
        
-
        在Swift语言中，你可以在循环体和switch代码块中嵌套循环体和switch代码块来创造复杂的控制流结构。然而，循环体和switch代码块两者都可以使用break语句来提前结束整个方法体。因此，显示地指明break语句想要终止的是哪个循环体或者switch代码块,会很有用。类似地，如果你有许多嵌套的循环体，显示指明continue语句想要影响哪一个循环体也会非常有用。
        
+
        
+
        带标签的语句（Labeled Statements）
        
+
        在 Swift 中，你可以在循环体和switch代码块中嵌套循环体和switch代码块来创造复杂的控制流结构。然而，循环体和switch代码块两者都可以使用break语句来提前结束整个方法体。因此，显示地指明break语句想要终止的是哪个循环体或者switch代码块，会很有用。类似地，如果你有许多嵌套的循环体，显示指明continue语句想要影响哪一个循环体也会非常有用。
        
 
        为了实现这个目的，你可以使用标签来标记一个循环体或者switch代码块，当使用break或者continue时，带上这个标签，可以控制该标签代表对象的中断或者执行。
        
 
        产生一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，并且该标签后面还需带着一个冒号。下面是一个while循环体的语法，同样的规则适用于所有的循环体和switch代码块。
        
-
        label name: while condition {
-    statements
+
        `label name`: while `condition` {
+    `statements`
 }
-
        下面的例子是在一个带有标签的while循环体中调用break和continue语句，该循环体是上述章节中蛇梯棋游戏的改编版本。这次，游戏增加了一条额外的规则：
        
+
        下面的例子是在一个带有标签的while循环体中调用break和continue语句，该循环体是前面章节中蛇和梯子的改编版本。这次，游戏增加了一条额外的规则：
        
 
          
-
        • 为了获胜，你必须刚好落在方格25中。
          • 
+
        • 为了获胜，你必须刚好落在第 25 个方块中。
          • 
 
        
-
        如果某次掷骰子使你的移动超出方格25，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在方格25中。
        
+
        如果某次掷骰子使你的移动超出第 25 个方块，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在第 25 个方块中。
        
 
        游戏的棋盘和之前一样：
        
 
        image
        
-
        值finalSquare,board,square和diceRoll的初始化也和之前一样：
        
-
        let finalSquare = 25
+
        值finalSquare、board、square和diceRoll的初始化也和之前一样：
        
+
        let finalSquare = 25
 var board = Int[](count: finalSquare + 1, repeatedValue: 0)
 board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
 var square = 0
 var diceRoll = 0
-
        这个版本的游戏使用while循环体和switch方法块来实现游戏的逻辑。while循环体有一个标签名gameLoop，来表明它是蛇梯棋游戏的主循环。
        
-
        该while循环体的条件判断语句是while square !=finalSquare,这表明你必须刚好落在方格25中。
        
-
        gameLoop: while square != finalSquare {
+
        
+
        这个版本的游戏使用while循环体和switch方法块来实现游戏的逻辑。while循环体有一个标签名gameLoop，来表明它是蛇与梯子的主循环。
        
+
        该while循环体的条件判断语句是while square !=finalSquare，这表明你必须刚好落在方格25中。
        
+
        gameLoop: while square != finalSquare {
     if ++diceRoll == 7 { diceRoll = 1 }
     switch square + diceRoll {
     case finalSquare:
-        // diceRoll will move us to the final square, so the game is over
+        // 到达最后一个方块，游戏结束
         break gameLoop
     case let newSquare where newSquare > finalSquare:
-        // diceRoll will move us beyond the final square, so roll again
+        // 超出最后一个方块，再掷一次骰子
         continue gameLoop
     default:
-        // this is a valid move, so find out its effect
+        // 本次移动有效
         square += diceRoll
         square += board[square]
     }
 }
 println("Game over!")
-
        每次循环迭代开始时掷骰子。与之前玩家掷完骰子就立即移动不同，这里使用了switch来考虑每次移动可能产生的结果，从而决定玩家本次是否能够移动。
        
+
        
+
        每次循环迭代开始时掷骰子。与之前玩家掷完骰子就立即移动不同，这里使用了switch来考虑每次移动可能产生的结果，从而决定玩家本次是否能够移动。
        
 
          
 
        • 如果骰子数刚好使玩家移动到最终的方格里，游戏结束。break gameLoop语句跳转控制去执行while循环体后的第一行代码，游戏结束。
          
 
          • 
@@ -1087,8 +1143,8 @@ println("Game over!")
 
 
        
 
        
-
        NOTE
-如果上述的break语句没有使用gameLoop标签，那么它将会中断switch代码块而不是while循环体。使用gameLoop标签清晰的表明了break想要中断的是哪个代码块。
+
        注意：
        
+
        如果上述的break语句没有使用gameLoop标签，那么它将会中断switch代码块而不是while循环体。使用gameLoop标签清晰的表明了break想要中断的是哪个代码块。
 同时请注意，当调用continue gameLoop去跳转到下一次循环迭代时，这里使用gameLoop标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以continue语句会影响到哪个循环体是没有歧义的。然而，continue语句使用gameLoop标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的break gameLoop，能够使游戏的逻辑更加清晰和易于理解。
        
 
        
 
@@ -1136,6 +1192,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/06_Functions.html b/chapter2/06_Functions.html
index 1a045ce9..ff2e636b 100644
--- a/chapter2/06_Functions.html
+++ b/chapter2/06_Functions.html
@@ -5,12 +5,12 @@
         
         
         
-        函数 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,45 +587,51 @@
 
                 
        
                 
-                    
        
+                    
        
                     
-                        
        函数（Functions）
        
+                        
        
+
        翻译：honghaoz
        
+
        校对：LunaticM
        
+
        
+
        函数（Functions）
        
 
        
 
        本页包含内容：
        
 
 
        函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标示函数做什么，并且当函数需要执行的时候，这个名字会被“调用”。
        
-
        Swift统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的C风格函数，到复杂的带局部和外部参数名的Objective-C风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。
        
-
        在Swift中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
        
+
        Swift 统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。
        
+
        在 Swift 中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
+
        
 
        函数的定义与调用（Defining and Calling Functions）
        
 
        当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入（称为参数，parameters），也可以定义某种类型的值作为函数执行结束的输出（称为返回类型）。
        
 
        每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，你用函数名“调用”，并传给它匹配的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。
        
-
        在下面例子中的函数叫做"greetingForPerson"，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做personName的String值，和一个包含给这个人问候语的String类型的返回值：
        
+
        在下面例子中的函数叫做"greetingForPerson"，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做 personName 的 String 值，和一个包含给这个人问候语的 String 类型的返回值：
        
 
        func sayHello(personName: String) -> String {
     let greeting = "Hello, " + personName + "!"
     return greeting
 }
-
        所有的这些信息汇总起来成为函数的定义，并以func作为前缀。指定函数返回类型时，用返回箭头->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。
        
+

        • 所有的这些信息汇总起来成为函数的定义，并以 func 作为前缀。指定函数返回类型时，用返回箭头 ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。

        该定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么。这样的定义使的函数可以在别的地方以一种清晰的方式被调用：

        println(sayHello("Anna"))
 // prints "Hello, Anna!"
 println(sayHello("Brian"))
 // prints "Hello, Brian!
-

        调用sayHello函数时，在圆括号中传给它一个String类型的实参。因为这个函数返回一个String类型的值，sayHello可以被包含在println的调用中，用来输出这个函数的返回值，正如上面所示。

        -

        在sayHello的函数体中，先定义了一个新的名为greeting的String常量，同时赋值了给personName的一个简单问候消息。然后用return关键字把这个问候返回出去。一旦return greeting被调用，该函数结束它的执行并返回greeting的当前值。

        -

        你可以用不同的输入值多次调用sayHello。上面的例子展示的是用"Anna"和"Brian"调用的结果，该函数分别返回了不同的结果。

        +

        调用 sayHello 函数时，在圆括号中传给它一个 String 类型的实参。因为这个函数返回一个 String 类型的值，sayHello 可以被包含在 println 的调用中，用来输出这个函数的返回值，正如上面所示。

        +

        在 sayHello 的函数体中，先定义了一个新的名为 greeting 的 String 常量，同时赋值了给 personName 的一个简单问候消息。然后用 return 关键字把这个问候返回出去。一旦 return greeting 被调用，该函数结束它的执行并返回 greeting 的当前值。

        +

        你可以用不同的输入值多次调用 sayHello。上面的例子展示的是用"Anna"和"Brian"调用的结果，该函数分别返回了不同的结果。

        为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：

        func sayHelloAgain(personName: String) -> String {
     return "Hello again, " + personName + "!"
 }
 println(sayHelloAgain("Anna"))
 // prints "Hello again, Anna!
-

        函数参数与返回值（Function Parameters and Return Values）

        +

        +

        函数参数与返回值（Function Parameters and Return Values）

        函数参数与返回值在Swift中极为灵活。你可以定义任何类型的函数，包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。

        多重输入参数（Multiple Input Parameters）

        函数可以有多个输入参数，写在圆括号中，用逗号分隔。

        @@ -636,7 +642,7 @@ println(sayHelloAgain("Anna")) println(halfOpenRangeLength(1, 10)) // prints "9

        无参函数（Functions Without Parameters）

        -

        函数可以没有参数。下面这个函数就是一个无参函数，当被调用时，它返回固定的String消息：

        +

        函数可以没有参数。下面这个函数就是一个无参函数，当被调用时，它返回固定的 String 消息：

        func sayHelloWorld() -> String {
     return "hello, world"
 }
@@ -644,7 +650,7 @@ println(sayHelloWorld())
 // prints "hello, world

        尽管这个函数没有参数，但是定义中在函数名后还是需要一对圆括号。当被调用时，也需要在函数名后写一对圆括号。

        无返回值函数（Functions Without Return Values）

        -

        函数可以没有返回值。下面是sayHello函数的另一个版本，叫waveGoodbye，这个函数直接输出String值，而不是返回它：

        +

        函数可以没有返回值。下面是 sayHello 函数的另一个版本，叫 waveGoodbye，这个函数直接输出 String 值，而不是返回它：

        func sayGoodbye(personName: String) {
     println("Goodbye, \(personName)!")
 }
@@ -652,8 +658,8 @@ sayGoodbye("Dave")
 // prints "Goodbye, Dave!

        因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。

        -

        注意： -严格上来说，虽然没有返回值被定义，sayGoodbye函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()。

        +

        注意：

        +

        严格上来说，虽然没有返回值被定义，sayGoodbye 函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫 Void。它其实是一个空的元组（tuple），没有任何元素，可以写成()。

        被调用时，一个函数的返回值可以被忽略：

        func printAndCount(stringToPrint: String) -> Int {
@@ -667,14 +673,14 @@ printAndCount("hello, world")
 // prints "hello, world" and returns a value of 12
 printWithoutCounting("hello, world")
 // prints "hello, world" but does not return a value
-

        第一个函数printAndCount，输出一个字符串并返回Int类型的字符数。第二个函数printWithoutCounting调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。

        +

        第一个函数 printAndCount，输出一个字符串并返回 Int 类型的字符数。第二个函数 printWithoutCounting调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。

        -

        注意： -返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，这叫导致编译错误（compile-time error）。

        +

        注意：

        +

        返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，这叫导致编译错误（compile-time error）。

        多重返回值函数（Functions with Multiple Return Values）

        你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。

        -

        下面的这个例子中，count函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。

        +

        下面的这个例子中，count 函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。

        func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
     var vowels = 0, consonants = 0, others = 0
     for character in string {
@@ -690,12 +696,13 @@ printWithoutCounting("hello, world")
     }
     return (vowels, consonants, others)
 }
-

        你可以用count函数来处理任何一个字符串，返回的值将是一个包含三个Int型值的元组（tuple）：

        +

        你可以用 count 函数来处理任何一个字符串，返回的值将是一个包含三个 Int 型值的元组（tuple）：

        let total = count("some arbitrary string!")
 println("\(total.vowels) vowels and \(total.consonants) consonants")
 // prints "6 vowels and 13 consonants
-

        需要注意的是，元组的成员不需要在函数中返回时命名，因为它们的名字已经在函数返回类型有有了定义。

        -

        函数参数名（Function Parameter Names）

        +

        需要注意的是，元组的成员不需要在函数中返回时命名，因为它们的名字已经在函数返回类型有有了定义。 +

        +

        函数参数名称（Function Parameter Names）

        以上所有的函数都给它们的参数定义了参数名（parameter name）：

        func someFunction(parameterName: Int) {
     // function body goes here, and can use parameterName
@@ -710,8 +717,8 @@ println("\(total.vowels) vowels and \(total.consonants) consonants")
     // to refer to the argument value for that parameter
 }
        -

        注意： -如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

        +

        注意：

        +

        如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

        以下是个例子，这个函数使用一个结合者（joiner）把两个字符串联在一起：

        func join(s1: String, s2: String, joiner: String) -> String {
@@ -720,22 +727,22 @@ println("\(total.vowels) vowels and \(total.consonants) consonants")

        当你调用这个函数时，这三个字符串的用途是不清楚的：

        join("hello", "world", ", ")
 // returns "hello, world
-

        为了让这些字符串的用途更为明显，我们为join函数添加外部参数名：

        +

        为了让这些字符串的用途更为明显，我们为 join 函数添加外部参数名：

        func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
     return s1 + joiner + s2
 }
-

        在这个版本的join函数中，第一个参数有一个叫string的外部参数名和s1的局部参数名，第二个参数有一个叫toString的外部参数名和s2的局部参数名，第三个参数有一个叫withJoiner的外部参数名和joiner的局部参数名。

        +

        在这个版本的 join 函数中，第一个参数有一个叫 string 的外部参数名和 s1 的局部参数名，第二个参数有一个叫 toString 的外部参数名和 s2 的局部参数名，第三个参数有一个叫 withJoiner 的外部参数名和 joiner 的局部参数名。

        现在，你可以使用这些外部参数名以一种清晰地方式来调用函数了：

        join(string: "hello", toString: "world", withJoiner: ", ")
 // returns "hello, world
-

        使用外部参数名让第二个版本的join函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。

        +

        使用外部参数名让第二个版本的 join 函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。

        -

        注意： -当其他人在第一次读你的代码，函数参数的意图显得不明显时，考虑使用外部参数名。如果函数参数名的意图是很明显的，那就不需要定义外部参数名了。

        +

        注意：

        +

        当其他人在第一次读你的代码，函数参数的意图显得不明显时，考虑使用外部参数名。如果函数参数名的意图是很明显的，那就不需要定义外部参数名了。

        简写外部参数名（Shorthand External Parameter Names）

        -

        如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用井号（#）作为前缀就可以了。这告诉Swift使用这个参数名作为局部和外部参数名。

        -

        下面这个例子定义了一个叫containsCharacter的函数，使用井号（#）的方式定义了外部参数名：

        +

        如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用井号（#）作为前缀就可以了。这告诉 Swift 使用这个参数名作为局部和外部参数名。

        +

        下面这个例子定义了一个叫 containsCharacter 的函数，使用井号（#）的方式定义了外部参数名：

        func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
     for character in string {
         if character == characterToFind {
@@ -750,36 +757,36 @@ println("\(total.vowels) vowels and \(total.consonants) consonants")

        默认参数值（Default Parameter Values）

        你可以在函数体中为每个参数定义默认值。当默认值被定义后，调用这个函数时可以略去这个参数。

        -

        注意： -将带有默认值的参数放在函数参数表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。

        +

        注意：

        +

        将带有默认值的参数放在函数参数表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。

        以下是另一个版本的join函数，其中joiner有了默认参数值：

        func join(string s1: String, toString s2: String, withJoiner joiner: String = " ") -> String {
     return s1 + joiner + s2
 }
-

        像第一个版本的join函数一样，如果joiner被幅值时，函数将使用这个字符串值来连接两个字符串：

        +

        像第一个版本的 join 函数一样，如果 joiner 被赋值时，函数将使用这个字符串值来连接两个字符串：

        join(string: "hello", toString: "world", withJoiner: "-")
 // returns "hello-world
-

        当这个函数被调用时，如果joiner的值没有被指定，函数会使用默认值（" "）：

        +

        当这个函数被调用时，如果 joiner 的值没有被指定，函数会使用默认值（" "）：

        join(string: "hello", toString:"world")
 // returns "hello world"

        默认值参数的外部参数名（External Names for Parameters with Default Values）

        在大多数情况下，给带默认值的参数起一个外部参数名是很有用的。这样可以保证当函数被调用且带默认值的参数被提供值时，实参的意图是明显的。

        -

        为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了井号（#）一样。

        -

        下面是join函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是joiner参数依然有外部参数名：

        +

        为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift 会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了井号（#）一样。

        +

        下面是 join 函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是 joiner 参数依然有外部参数名：

        func join(s1: String, s2: String, joiner: String = " ") -> String {
     return s1 + joiner + s2
 }
-

        在这个例子中，Swift自动为joiner提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。

        +

        在这个例子中，Swift 自动为 joiner 提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。

        join("hello", "world", joiner: "-")
 // returns "hello-world"
        -

        注意： -你可以使用下划线（_）作为默认值参数的外部参数名，这样可以在调用时不用提供外部参数名。但是给带默认值的参数命名总是更加合适的。

        +

        注意：

        +

        你可以使用下划线（_）作为默认值参数的外部参数名，这样可以在调用时不用提供外部参数名。但是给带默认值的参数命名总是更加合适的。

        可变参数（Variadic Parameters）

        一个可变参数（variadic parameter）可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入（...）的方式来定义可变参数。

        -

        传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做numbers的Double...型可变参数，在函数体内可以当做一个叫numbers的Double[]型的数组常量。

        +

        传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 Double[] 型的数组常量。

        下面的这个函数用来计算一组任意长度数字的算术平均数：

        func arithmeticMean(numbers: Double...) -> Double {
     var total: Double = 0
@@ -793,14 +800,14 @@ arithmeticMean(1, 2, 3, 4, 5)
 arithmeticMean(3, 8, 19)
 // returns 10.0, which is the arithmetic mean of these three numbers
        -

        注意： -一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。

        +

        注意：

        +

        一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。

        如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。

        常量参数和变量参数（Constant and Variable Parameters）

        函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。

        但是，有时候，如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数，从而避免自己在函数中定义新的变量。变量参数不是常量，你可以在函数中把它当做新的可修改副本来使用。

        -

        通过在参数名前加关键字var来定义变量参数：

        +

        通过在参数名前加关键字 var 来定义变量参数：

        func alignRight(var string: String, count: Int, pad: Character) -> String {
     let amountToPad = count - countElements(string)
     for _ in 1...amountToPad {
@@ -812,40 +819,41 @@ let originalString = "hello"
 let paddedString = alignRight(originalString, 10, "-")
 // paddedString is equal to "-----hello"
 // originalString is still equal to "hello"
-

        这个例子中定义了一个新的叫做alignRight的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串"hello"被转换成了"-----hello"。

        -

        alignRight函数将参数string定义为变量参数。这意味着string现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。

        -

        该函数首先计算出多少个字符需要被添加到string的左边，以右对齐到总的字符串中。这个值存在局部常量amountToPad中。这个函数然后将amountToPad多的填充（pad）字符填充到string左边，并返回结果。它使用了string这个变量参数来进行所有字符串操作。

        +

        这个例子中定义了一个新的叫做 alignRight 的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串"hello"被转换成了"-----hello"。

        +

        alignRight 函数将参数 string 定义为变量参数。这意味着 string 现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。

        +

        该函数首先计算出多少个字符需要被添加到 string 的左边，以右对齐到总的字符串中。这个值存在局部常量 amountToPad 中。这个函数然后将 amountToPad 多的填充（pad）字符填充到 string 左边，并返回结果。它使用了 string 这个变量参数来进行所有字符串操作。

        -

        注意： -对变量参数所进行的修改在函数调用结束后变消息了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。

        +

        注意：

        +

        对变量参数所进行的修改在函数调用结束后变消息了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。

        输入输出参数（In-Out Parameters）

        变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。

        -

        定义一个输入输出参数时，在参数定义前加inout关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。

        +

        定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。

        你只能传入一个变量作为输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加&符，表示这个值可以被函数修改。

        -

        注意： -输入输出参数不能有默认值，而且变量参数不能用inout标记。如果你用inout标记一个参数，这个参数不能别var或者let标记。

        +

        注意：

        +

        输入输出参数不能有默认值，而且变量参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能别 var 或者 let 标记。

        -

        下面是例子，swapTwoInts函数，有两个分别叫做a和b的输出输出参数：

        +

        下面是例子，swapTwoInts 函数，有两个分别叫做 a 和 b 的输出输出参数：

        func swapTwoInts(inout a: Int, inout b: Int) {
     let temporaryA = a
     a = b
     b = temporaryA
 }
-

        这个swapTwoInts函数仅仅交换a与b的值。该函数先将a的值存到一个暂时常量temporaryA中，然后将b的值赋给a，最后将temporaryA幅值给b。

        -

        你可以用两个Int型的变量来调用swapTwoInts。需要注意的是，someInt和anotherInt在传入swapTwoInts函数前，都加了&的前缀：

        +

        这个 swapTwoInts 函数仅仅交换 a 与 b 的值。该函数先将 a 的值存到一个暂时常量 temporaryA 中，然后将 b 的值赋给 a，最后将 temporaryA 幅值给 b。

        +

        你可以用两个 Int 型的变量来调用 swapTwoInts。需要注意的是，someInt 和 anotherInt 在传入 swapTwoInts 函数前，都加了 & 的前缀：

        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”
-

        从上面这个例子中，我们可以看到someInt和anotherInt的原始值在swapTwoInts函数中被修改，尽管它们的定义在函数体外。

        +

        从上面这个例子中，我们可以看到 someInt 和 anotherInt 的原始值在 swapTwoInts 函数中被修改，尽管它们的定义在函数体外。

        -

        注意： -输出输出参数和返回值是不一样的。上面的swapTwoInts函数并没有定义任何返回值，但仍然修改了someInt和anotherInt的值。输入输出参数是函数对函数体外产生影响的另一种方式。

        -
        +

        注意：

        +

        输出输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。 +

        函数类型（Function Types）

        +

        每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。

        例如：

        func addTwoInts(a: Int, b: Int) -> Int {
@@ -854,27 +862,27 @@ println("someInt is now \(someInt), and anotherInt is now \(anotherInt)&quo
 func multiplyTwoInts(a: Int, b: Int) -> Int {
     return a * b
 }
-

        这个例子中定义了两个简单的数学函数：addTwoInts和multiplyTwoInts。这两个函数都传入两个Int类型， 返回一个合适的Int值。

        -

        这两个函数的类型是(Int, Int) -> Int，可以读作“这个函数类型，它有两个Int型的参数并返回一个Int型的值。”。

        +

        这个例子中定义了两个简单的数学函数：addTwoInts 和 multiplyTwoInts。这两个函数都传入两个 Int 类型， 返回一个合适的Int值。

        +

        这两个函数的类型是 (Int, Int) -> Int，可以读作“这个函数类型，它有两个 Int 型的参数并返回一个 Int 型的值。”。

        下面是另一个例子，一个没有参数，也没有返回值的函数：

        func printHelloWorld() {
     println("hello, world")
 }
-

        这个函数的类型是：() -> ()，或者叫“没有参数，并返回Void类型的函数。”。没有指定返回类型的函数总返回 Void。在Swift中，Void与空的元组是一样的。

        +

        这个函数的类型是：() -> ()，或者叫“没有参数，并返回 Void 类型的函数。”。没有指定返回类型的函数总返回 Void。在Swift中，Void 与空的元组是一样的。

        使用函数类型（Using Function Types）

        在Swift中，使用函数类型就像使用其他类型一样。例如，你可以定义一个常量或变量，它的类型是函数，并且可以幅值为一个函数：

        var mathFunction: (Int, Int) -> Int = addTwoInts

        这个可以读作：

        -

        “定义一个叫做mathFunction的变量，类型是‘一个有两个Int型的参数并返回一个Int型的值的函数’，并让这个新变量指向addTwoInts函数”。

        -

        addTwoInts和mathFunction有同样的类型，所以这个赋值过程在Swift类型检查中是允许的。

        -

        现在，你可以用mathFunction来调用被赋值的函数了：

        +

        “定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。

        +

        addTwoInts 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。

        +

        现在，你可以用 mathFunction 来调用被赋值的函数了：

        println("Result: \(mathFunction(2, 3))")
 // prints "Result: 5

        有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：

        mathFunction = multiplyTwoInts
 println("Result: \(mathFunction(2, 3))")
 // prints "Result: 6"
-

        就像其他类型一样，当赋值一个函数给常量或变量时，你可以让Swift来推测其函数类型：

        +

        就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推测其函数类型：

        let anotherMathFunction = addTwoInts
 // anotherMathFunction is inferred to be of type (Int, Int) -> Int

        函数类型作为参数类型（Function Types as Parameter Types）

        @@ -885,28 +893,28 @@ println("Result: \(mathFunction(2, 3))") } printMathResult(addTwoInts, 3, 5) // prints "Result: 8” -

        这个例子定义了printMathResult函数，它有三个参数：第一个参数叫mathFunction，类型是(Int, Int) -> Int，你可以传入任何这种类型的函数；第二个和第三个参数叫a和b，它们的类型都是Int，这两个值作为已给的函数的输入值。

        -

        当printMathResult被调用时，它被传入addTwoInts函数和整数3和5。它用传入3和5调用addTwoInts，并输出结果：8。

        -

        printMathResult函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得printMathResult可以以一种类型安全（type-safe）的方式来保证传入函数的调用是正确的。

        +

        这个例子定义了 printMathResult 函数，它有三个参数：第一个参数叫 mathFunction，类型是(Int, Int) -> Int，你可以传入任何这种类型的函数；第二个和第三个参数叫 a 和 b，它们的类型都是 Int，这两个值作为已给的函数的输入值。

        +

        当 printMathResult 被调用时，它被传入 addTwoInts 函数和整数3和5。它用传入3和5调用 addTwoInts，并输出结果：8。

        +

        printMathResult 函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得 printMathResult 可以以一种类型安全（type-safe）的方式来保证传入函数的调用是正确的。

        函数类型作为返回类型（Function Type as Return Types）

        你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。

        -

        下面的这个例子中定义了两个简单函数，分别是stepForward和stepBackward。stepForward函数返回一个比输入值大一的值。stepBackward函数返回一个比输入值小一的值。这两个函数的类型都是(Int) -> Int：

        +

        下面的这个例子中定义了两个简单函数，分别是 stepForward 和stepBackward。stepForward 函数返回一个比输入值大一的值。stepBackward 函数返回一个比输入值小一的值。这两个函数的类型都是 (Int) -> Int：

        func stepForward(input: Int) -> Int {
     return input + 1
 }
 func stepBackward(input: Int) -> Int {
     return input - 1
 }
-

        下面这个叫做chooseStepFunction的函数，它的返回类型是(Int) -> Int的函数。chooseStepFunction根据布尔值backwards来返回stepForward函数或stepBackward函数：

        +

        下面这个叫做 chooseStepFunction 的函数，它的返回类型是 (Int) -> Int 的函数。chooseStepFunction 根据布尔值 backwards 来返回 stepForward 函数或 stepBackward 函数：

        func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
     return backwards ? stepBackward : stepForward
 }
-

        你现在可以用chooseStepFunction来获得一个函数，不管是那个方向：

        +

        你现在可以用 chooseStepFunction 来获得一个函数，不管是那个方向：

        var currentValue = 3
 let moveNearerToZero = chooseStepFunction(currentValue > 0)
 // moveNearerToZero now refers to the stepBackward() function
-

        上面这个例子中计算出从currentValue逐渐接近到0是需要向正数走还是向负数走。currentValue的初始值是3，这意味着currentValue > 0是真的（true），这将使得chooseStepFunction返回stepBackward函数。一个指向返回的函数的引用保存在了moveNearerToZero常量中。

        -

        现在，moveNearerToZero指向了正确的函数，它可以被用来数到0：

        +

        上面这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue 的初始值是3，这意味着 currentValue > 0 是真的（true），这将使得 chooseStepFunction 返回 stepBackward 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

        +

        现在，moveNearerToZero 指向了正确的函数，它可以被用来数到0：

        println("Counting to zero:")
 // Counting to zero:
 while currentValue != 0 {
@@ -918,10 +926,11 @@ println("zero!")
 // 2...
 // 1...
 // zero!
-

        嵌套函数（Nested Functions）

        +

        +

        嵌套函数（Nested Functions）

        这章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。

        默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。

        -

        你可以用返回嵌套函数的方式重写chooseStepFunction函数：

        +

        你可以用返回嵌套函数的方式重写 chooseStepFunction 函数：

        func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
     func stepForward(input: Int) -> Int { return input + 1 }
     func stepBackward(input: Int) -> Int { return input - 1 }
@@ -985,6 +994,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/07_Closures.html b/chapter2/07_Closures.html
index a05a86c2..8e829af9 100644
--- a/chapter2/07_Closures.html
+++ b/chapter2/07_Closures.html
@@ -5,12 +5,12 @@
         
         
         
-        闭包 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,26 +587,30 @@
 
                 
        
                 
-                    
        
+                    
        
                     
-                        
        闭包
        
+                        
        
+
        翻译：wh1100717
        
+
        校对：lyuka
        
+
        
+
        闭包（Closures）
        
 
        
-
        本页内容包含：
        
+
        本页包含内容：
        
 
 
        闭包是自包含的函数代码块，可以在代码中被传递和使用。
-Swift 中的闭包与 C 和 Objective-C 中的blocks (代码块) 以及其他一些编程语言中的lambdas (匿名函数) 比较相似。
        
-
        闭包可以捕获和存储其所在上下文中任意常量和变量的引用。
-这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。
        
+Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。
        
+
        闭包可以捕获和存储其所在上下文中任意常量和变量的引用。
+这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。
        
 
        
-
        注意：
-如果您不熟悉捕获 (capturing) 这个概念也不用担心，您可以在 捕获值 章节对其进行详细了解。
        
+
        注意：
        
+
        如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 值捕获 章节对其进行详细了解。
        
 
        
-
        在函数 (这里需要函数章节提供相应链接进行配合) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
        
+
        在函数 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
        
 
          
 
        • 全局函数是一个有名字但不会捕获任何值的闭包
          • 
 
        • 嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
          • 
@@ -617,29 +621,28 @@ Swift 中的闭包与 C 和 Objective-C 中的blocks (代码块) 
 
        • 利用上下文推断参数和返回值类型
          • 
 
        • 隐式返回单表达式闭包，即单表达式闭包可以省略return关键字
          • 
 
        • 参数名称缩写
          • 
-
        • 尾随 (Trailing) 闭包语法
          • 
+
        • 尾随（Trailing）闭包语法
          • 
 
        
 
        
-
        闭包表达式 (Closure Expressions)
        
-
        
-
        嵌套函数 (这里需要函数章节提供相应链接及锚点进行配合) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
+
        闭包表达式（Closure Expressions）
        
+
        嵌套函数 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
 当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
        
 
        闭包表达式是一种利用简洁语法构建内联闭包的方式。
 闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。
 下面闭包表达式的例子通过使用几次迭代展示了sort函数定义和语法优化的方式。
 每一次迭代都用更简洁的方式描述了相同的功能。
        
 
        
-
        sort 函数 (The Sort Function)
        
+
        sort 函数（The Sort Function）
        
 
        Swift 标准库提供了sort函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
        
-
        下面的闭包表达式示例使用sort函数对一个 String 类型的数组进行字母逆序排序，以下是初始数组值：
        
+
        下面的闭包表达式示例使用sort函数对一个String类型的数组进行字母逆序排序，以下是初始数组值：
        
 
        let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 
        sort函数需要传入两个参数：
        
 
          
 
        • 已知类型的数组
          • 
 
        • 闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉sort函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回true，反之返回false。
          • 
 
        
-
        该例子对一个 String 类型的数组进行排序，因此排序闭包函数类型需为(String, String) -> Bool。
        
+
        该例子对一个String类型的数组进行排序，因此排序闭包函数类型需为(String, String) -> Bool。
        
 
        提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为sort函数的第二个参数传入：
        
 
        func backwards(s1: String, s2: String) -> Bool {
     return s1 > s2
@@ -647,18 +650,18 @@ Swift 中的闭包与 C 和 Objective-C 中的blocks (代码块) 
 var reversed = sort(names, backwards)
 // reversed 为 ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
 
        如果第一个字符串 (s1) 大于第二个字符串 (s2)，backwards函数返回true，表示在新的数组中s1应该出现在s2前。
-对于字符串中的字符来说，"大于" 表示 "按照字母顺序较晚出现"。
+对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。
 这意味着字母"B"大于字母"A"，字符串"Tom"大于字符串"Tim"。
 其将进行字母逆序排序，"Barry"将会排在"Alex"之后。
        
 
        然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。
 在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
        
 
        
-
        闭包表达式语法 (Closure Expression Syntax)
        
+
        闭包表达式语法（Closure Expression Syntax）
        
 
        闭包表达式语法有如下一般形式：
        
 
        { (parameters) -> returnType in
     statements
 }
-
        闭包表达式语法可以使用常量、变量和inout (这里也需要函数章节提供相应链接和锚点进行配合) 类型作为参数，不提供默认值。
+

        • 闭包表达式语法可以使用常量、变量和inout类型作为参数，不提供默认值。 也可以在参数列表的最后使用可变参数。 元组也可以作为参数和返回值。

        下面的例子展示了之前backwards函数对应的闭包表达式版本的代码：

        @@ -672,40 +675,39 @@ var reversed = sort(names, backwards) 该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。

        因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：

        reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
-

        这说明sort函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于backwards版本的代码)。

        +

        这说明sort函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于backwards版本的代码）。

        -
        根据上下文推断类型 (Inferring Type From Context)
        +

        根据上下文推断类型（Inferring Type From Context）

        因为排序闭包函数是作为sort函数的参数进行传入的，Swift可以推断其参数和返回值的类型。 sort期望第二个参数是类型为(String, String) -> Bool的函数，因此实际上String,String和Bool类型并不需要作为闭包表达式定义中的一部分。 因为所有的类型都可以被正确推断，返回箭头 (->) 和围绕在参数周围的括号也可以被省略：

        reversed = sort(names, { s1, s2 in return s1 > s2 } )

        实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。

        -
        单表达式闭包隐式返回 (Implicit Return From Single-Expression Clossures)
        +

        单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures）

        单行表达式闭包可以通过隐藏return关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：

        reversed = sort(names, { s1, s2 in s1 > s2 } )
-

        在这个例子中，sort函数的第二个参数函数类型明确了闭包必须返回一个 Bool 类型值。 -因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回 Bool 类型值，因此这里没有歧义，return关键字可以省略。

        +

        在这个例子中，sort函数的第二个参数函数类型明确了闭包必须返回一个Bool类型值。 +因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回Bool类型值，因此这里没有歧义，return关键字可以省略。

        -
        参数名称缩写 (Shorthand Argument Names)
        +

        参数名称缩写（Shorthand Argument Names）

        Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。

        如果您在闭包表达式中使用参数名称缩写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称缩写的类型会通过函数类型进行推断。 in关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：

        reversed = sort(names, { $0 > $1 } )
-

        在这个例子中，$0和$1表示闭包中第一个和第二个 String 类型的参数。

        +

        在这个例子中，$0和$1表示闭包中第一个和第二个String类型的参数。

        -
        运算符函数 (Operator Functions)
        +

        运算符函数（Operator Functions）

        实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。 -Swift 的 String 类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值。 +Swift 的String类型定义了关于大于号 (>) 的字符串实现，其作为一个函数接受两个String类型的参数并返回Bool类型的值。 而这正好与sort函数的第二个参数需要的函数类型相符合。 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：

        reversed = sort(names, >)
-

        更多关于运算符表达式的内容请查看 Operator Functions (这里需要 Operator Functions 进行配合)。

        +

        更多关于运算符表达式的内容请查看 运算符函数。

        -

        尾随闭包 (Trailing Closures)

        -
        +

        尾随闭包（Trailing Closures）

        如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。 -尾随闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。

        +尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。

        func someFunctionThatTakesAClosure(closure: () -> ()) {
     // 函数体部分
 }
@@ -722,18 +724,17 @@ someFunctionThatTakesAClosure() {
     // 闭包主体部分
 }
        -

        注意： -如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把 () 省略掉。 -NOTE

        +

        注意：

        +

        如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把()省略掉。

        在上例中作为sort函数参数的字符串排序闭包可以改写为：

        reversed = sort(names) { $0 > $1 }

        当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。 -举例来说，Swift 的 Array 类型有一个map方法，其获取一个闭包表达式作为其唯一参数。 +举例来说，Swift 的Array类型有一个map方法，其获取一个闭包表达式作为其唯一参数。 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。 具体的映射方式和返回值类型由闭包来指定。

        当提供给数组闭包函数后，map方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。

        -

        下例介绍了如何在map方法中使用尾随闭包将 Int 类型数组[16,58,510]转换为包含对应 String 类型的数组["OneSix", "FiveEight", "FiveOneZero"]:

        +

        下例介绍了如何在map方法中使用尾随闭包将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"
@@ -756,26 +757,25 @@ let numbers = [16, 58, 510]
 // 其值为 ["OneSix", "FiveEight", "FiveOneZero"]

        map在数组中为每一个元素调用了闭包表达式。 您不需要指定闭包的输入参数number的类型，因为可以通过要映射的数组类型进行推断。

        -

        闭包number参数被声明为一个变量参数 (变量的具体描述请参看Constant and Variable Parameters(这里需要Closure Expression Syntax进行配合))，因此可以在闭包函数体内对其进行修改。 -闭包表达式制定了返回类型为 String，以表明存储映射值的新数组类型为 String。

        +

        闭包number参数被声明为一个变量参数（变量的具体描述请参看常量参数和变量参数），因此可以在闭包函数体内对其进行修改。 +闭包表达式制定了返回类型为String，以表明存储映射值的新数组类型为String。

        闭包表达式在每次被调用的时候创建了一个字符串并返回。 其使用求余运算符 (number % 10) 计算最后一位数字并利用digitNames字典获取所映射的字符串。

        -

        注意： -字典digitNames下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。 +

        注意：

        +

        字典digitNames下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该 key 不存在也不会查找失败。 在上例中，它保证了number % 10可以总是作为一个digitNames字典的有效下标 key。 -因此叹号可以用于强制解析 (force-unwrap) 存储在可选下标项中的 String 类型值。

        +因此叹号可以用于强制解析 (force-unwrap) 存储在可选下标项中的String类型值。

        从digitNames字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。 -(在表达式number % 10中，如果number为16，则返回6，58返回8，510返回0)。

        +（在表达式number % 10中，如果number为16，则返回6，58返回8，510返回0）。

        number变量之后除以10。 因为其是整数，在计算过程中未除尽部分被忽略。 因此 16变成了1，58变成了5，510变成了51。

        整个过程重复进行，直到number /= 10为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。

        上例中尾随闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在map函数的括号内。

        -

        捕获值 (Capturing Values)

        -
        +

        捕获值（Capturing Values）

        闭包可以在其定义的上下文中捕获常量或变量。 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

        Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数。 @@ -794,11 +794,11 @@ let numbers = [16, 58, 510] }

        makeIncrementor返回类型为() -> Int。 这意味着其返回的是一个函数，而不是一个简单类型值。 -该函数在每次调用时不接受参数只返回一个 Int 类型的值。 -关于函数返回其他函数的内容，请查看Function Types as Return Types(需要函数章节进行配合)。

        +该函数在每次调用时不接受参数只返回一个Int类型的值。 +关于函数返回其他函数的内容，请查看函数类型作为返回类型。

        makeIncrementor函数定义了一个整型变量runningTotal(初始为0) 用来存储当前跑步总数。 该值通过incrementor返回。

        -

        makeIncrementor有一个 Int 类型的参数，其外部命名为forIncrement， 内部命名为amount，表示每次incrementor被调用时runningTotal将要增加的量。

        +

        makeIncrementor有一个Int类型的参数，其外部命名为forIncrement， 内部命名为amount，表示每次incrementor被调用时runningTotal将要增加的量。

        incrementor函数用来执行实际的增加操作。 该函数简单地使runningTotal增加amount，并将其返回。

        如果我们单独看这个函数，会发现看上去不同寻常：

        @@ -810,8 +810,8 @@ let numbers = [16, 58, 510]

        由于没有修改amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor一同被存储。

        然而，因为每次调用该函数的时候都会修改runningTotal的值，incrementor捕获了当前runningTotal变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeIncrementor结束时候并不会消失，也保证了当下一次执行incrementor函数时，runningTotal可以继续增加。

        -

        注意： -Swift 会决定捕获引用还是拷贝值。 +

        注意：

        +

        Swift 会决定捕获引用还是拷贝值。 您不需要标注amount或者runningTotal来声明在嵌入的incrementor函数中的使用方式。 Swift 同时也处理runingTotal变量的内存管理操作，如果不再被incrementor函数使用，则会被清除。

        @@ -833,13 +833,12 @@ incrementBySeven() incrementByTen() // 返回的值为40
        -

        注意： -如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。 -Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 Strong Reference Cycles for Closures(需要ARC章节进行配合)。

        +

        注意：

        +

        如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。 +Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 闭包引起的循环强引用。

        -

        闭包是引用类型

        -
        +

        闭包是引用类型（Closures Are Reference Types）

        上面的例子中，incrementBySeven和incrementByTen是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。 这是因为函数和闭包都是引用类型。

        无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。 @@ -893,6 +892,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/08_Enumerations.html b/chapter2/08_Enumerations.html index c4e522b0..2319c982 100644 --- a/chapter2/08_Enumerations.html +++ b/chapter2/08_Enumerations.html @@ -5,12 +5,12 @@ - 枚举 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -

        +
        @@ -98,7 +98,7 @@

        - Swift 编程语言 + 这一次，让中国和世界同步

        @@ -119,7 +119,7 @@
      • - Introduction + 序
        • @@ -331,7 +331,7 @@
      • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,22 +587,26 @@
        -
        +
        -

        枚举（Enumerations）

        +
        +

        翻译：yankuangshi

        +

        校对：shinyzhu

        +
        +

        枚举（Enumerations）

        本页内容包含：

        -

        枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。

        -

        如果你熟悉 C 语言，你就会知道，在 C 语言中枚举指定相关名称为一组整型值。Swift 中的枚举更加灵活，不必给每一个枚举成员（enumeration member）提供一个值。如果一个值（被认为是“原始”值）被提供给每个枚举成员，则该值可以是一个字符串，一个字符，或是一个整型值或浮点值。

        -

        此外，枚举成员可以指定任何类型的关联值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。

        -

        在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多传统上只被类所支持的特征，例如计算型属性（computed properties)，用于提供关于枚举当前值的附加信息，实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造器（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。

        -

        欲了解更多相关功能，请参考属性，方法，构造过程，扩展，和协议。

        +

        枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。

        +

        如果你熟悉 C 语言，你就会知道，在 C 语言中枚举指定相关名称为一组整型值。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果一个值（被认为是“原始”值）被提供给每个枚举成员，则该值可以是一个字符串，一个字符，或是一个整型值或浮点值。

        +

        此外，枚举成员可以指定任何类型的实例值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。

        +

        在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多传统上只被类（class)所支持的特征，例如计算型属性（computed properties)，用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。

        +

        欲了解更多相关功能，请参见属性（Properties），方法（Methods），构造过程（Initialization），扩展（Extensions）和协议（Protocols）。

        枚举语法

        使用enum关键词并且把它们的整个定义放在一对大括号内：

        @@ -618,8 +622,8 @@ }

        一个枚举中被定义的值（例如 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的一种显示定义中拥有各自不同的值。

        多个成员值可以出现在同一行上，用逗号隔开：

        enum Planet {
@@ -644,11 +648,11 @@ case .East:
 case .West:
     println("Where the skies are blue")
 }
-// prints "Watch out for penguins”
+// 输出 "Watch out for penguins”

        你可以如此理解这段代码：

        “考虑directionToHead的值。当它等于.North，打印“Lots of planets have a north”。当它等于.South，打印“Watch out for penguins”。”

        等等依次类推。

        -

        正如在控制流中介绍，当考虑一个枚举的成员们时，一个switch语句必须全面。如果忽略了.West这种情况，上面那段代码将无法通过编译，因为它没有考虑到CompassPoint的全部成员。全面性的要求确保了枚举成员不会被意外遗漏。

        +

        正如在控制流（Control Flow）中介绍，当考虑一个枚举的成员们时，一个switch语句必须全面。如果忽略了.West这种情况，上面那段代码将无法通过编译，因为它没有考虑到CompassPoint的全部成员。全面性的要求确保了枚举成员不会被意外遗漏。

        当不需要匹配每个枚举成员的时候，你可以提供一个默认default分支来涵盖所有未明确被提出的任何成员：

        let somePlanet = Planet.Earth
 switch somePlanet {
@@ -657,14 +661,14 @@ case .Earth:
 default:
     println("Not a safe place for humans")
 }
-// prints "Mostly harmless”
+// 输出 "Mostly harmless”

        -

        关联值（Associated Values）

        -

        上一小节的例子演示了一个枚举的成员是如何被定义（分类）的。你可以为Planet.Earth设置一个常量或则变量，并且在之后查看这个值。然而，有时候会很有用如果能够把其他类型的关联值和成员值一起存储起来。这能让你随着成员值存储额外的自定义信息，并且当每次你在代码中利用该成员时允许这个信息产生变化。

        -

        你可以定义 Swift 的枚举存储任何类型的关联值，如果需要的话，每个成员的数据类型可以是各不相同的。枚举的这种特性跟其他语言中的可辨识联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。

        -

        例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维码，它使用数字0到9.每一个条形码都有一个代表“数字系统”的数字，该数字后接10个代表“标识符”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：

        -

        -

        其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO8859-1 字符，并且可以编码一个最多拥有2,953字符的字符串:

        +

        实例值（Associated Values）

        +

        上一小节的例子演示了一个枚举的成员是如何被定义（分类）的。你可以为Planet.Earth设置一个常量或则变量，并且在之后查看这个值。然而，有时候会很有用如果能够把其他类型的实例值和成员值一起存储起来。这能让你随着成员值存储额外的自定义信息，并且当每次你在代码中利用该成员时允许这个信息产生变化。

        +

        你可以定义 Swift 的枚举存储任何类型的实例值，如果需要的话，每个成员的数据类型可以是各不相同的。枚举的这种特性跟其他语言中的可辨识联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。

        +

        例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维码，它使用数字 0 到 9。每一个条形码都有一个代表“数字系统”的数字，该数字后接 10 个代表“标识符”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：

        +

        +

        其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO8859-1 字符，并且可以编码一个最多拥有 2,953 字符的字符串:

        对于库存跟踪系统来说，能够把 UPC-A 码作为三个整型值的元组，和把 QR 码作为一个任何长度的字符串存储起来是方便的。

        在 Swift 中，用来定义两种商品条码的枚举是这样子的：

        @@ -673,41 +677,41 @@ default: case QRCode(String) }

        以上代码可以这么理解：

        -

        “定义一个名为Barcode的枚举类型，它可以是UPCA的一个关联值（Int，Int，Int），或者QRCode的一个字符串类型（String）关联值。”

        -

        这个定义不提供任何Int或String的实际值，它只是定义了，当Barcode常量和变量等于Barcode.UPCA或Barcode.QRCode时，关联值的类型。

        +

        “定义一个名为Barcode的枚举类型，它可以是UPCA的一个实例值（Int，Int，Int），或者QRCode的一个字符串类型（String）实例值。”

        +

        这个定义不提供任何Int或String的实际值，它只是定义了，当Barcode常量和变量等于Barcode.UPCA或Barcode.QRCode时，实例值的类型。

        然后可以使用任何一种条码类型创建新的条码，如：

        var productBarcode = Barcode.UPCA(8, 85909_51226, 3)
-

        以上例子创建了一个名为productBarcode的新变量，并且赋给它一个Barcode.UPCA的关联元组值(8, 8590951226, 3)。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。

        +

        以上例子创建了一个名为productBarcode的新变量，并且赋给它一个Barcode.UPCA的实例元组值(8, 8590951226, 3)。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。

        同一个商品可以被分配给一个不同类型的条形码，如：

        productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
-

        这时，原始的Barcode.UPCA和其整数值被新的Barcode.QRCode和其字符串值所替代。条形码的常量和变量可以存储一个.UPCA或者一个.QRCode（连同它的关联值），但是在任何指定时间只能存储其中之一。

        -

        像以前那样，不同的条形码类型可以使用一个switch语句来检查，然而这次关联值可以被提取作为switch语句的一部分。你可以在switch的case分支代码中提取每个关联值作为一个常量（用let前缀）或者作为一个变量（用var前缀）来使用：

        +

        这时，原始的Barcode.UPCA和其整数值被新的Barcode.QRCode和其字符串值所替代。条形码的常量和变量可以存储一个.UPCA或者一个.QRCode（连同它的实例值），但是在任何指定时间只能存储其中之一。

        +

        像以前那样，不同的条形码类型可以使用一个 switch 语句来检查，然而这次实例值可以被提取作为 switch 语句的一部分。你可以在switch的 case 分支代码中提取每个实例值作为一个常量（用let前缀）或者作为一个变量（用var前缀）来使用：

        switch productBarcode {
 case .UPCA(let numberSystem, let identifier, let check):
     println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
 case .QRCode(let productCode):
     println("QR code with value of \(productCode).")
 }
-// prints "QR code with value of ABCDEFGHIJKLMNOP.”
-

        如果一个枚举成员的所有关联值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个var或者let标注在成员名称前：

        +// 输出 "QR code with value of ABCDEFGHIJKLMNOP.” +

        如果一个枚举成员的所有实例值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个var或者let标注在成员名称前：

        switch productBarcode {
 case let .UPCA(numberSystem, identifier, check):
     println("UPC-A with value of \(numberSystem), \(identifier), \(check).")
 case let .QRCode(productCode):
     println("QR code with value of \(productCode).")
 }
-// prints "QR code with value of ABCDEFGHIJKLMNOP."
+// 输出 "QR code with value of ABCDEFGHIJKLMNOP."

        原始值（Raw Values）

        -

        在关联值小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的关联值。作为关联值的替代，枚举成员可以被默认值（称为原始值）预先填充，其中这些原始值具有相同的类型。

        +

        在实例值小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的实例值。作为实例值的替代，枚举成员可以被默认值（称为原始值）预先填充，其中这些原始值具有相同的类型。

        这里是一个枚举成员存储原始 ASCII 值的例子：

        enum ASCIIControlCharacter: Character {
     case Tab = "\t"
     case LineFeed = "\n"
     case CarriageReturn = "\r"
 }
-

        在这里，称为ASCIIControlCharacter的枚举的原始值类型被定义为字符型Character，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符章节。

        -

        注意，原始值和关联值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。关联值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。

        +

        在这里，称为ASCIIControlCharacter的枚举的原始值类型被定义为字符型Character，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符Strings and Characters部分。

        +

        注意，原始值和实例值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。实例值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。

        原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。当整型值被用于原始值，如果其他枚举成员没有值时，它们会自动递增。

        下面的枚举是对之前Planet这个枚举的一个细化，利用原始整型值来表示每个 planet 在太阳系中的顺序：

        enum Planet: Int {
@@ -733,7 +737,7 @@ if let somePlanet = Planet.fromRaw(positionToFind) {
 } else {
     println("There isn't a planet at position \(positionToFind)")
 }
-// prints "There isn't a planet at position 9
+// 输出 "There isn't a planet at position 9

        这个范例使用可选绑定（optional binding），通过原始值9试图访问一个行星。if let somePlanet = Planet.fromRaw(9)语句获得一个可选Planet，如果可选Planet可以被获得，把somePlanet设置成该可选Planet的内容。在这个范例中，无法检索到位置为9的行星，所以else分支被执行。

        @@ -780,6 +784,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/09_Classes_and_Structures.html b/chapter2/09_Classes_and_Structures.html index 9ebb4f6c..85ec4d08 100644 --- a/chapter2/09_Classes_and_Structures.html +++ b/chapter2/09_Classes_and_Structures.html @@ -5,12 +5,12 @@ - 类和结构体 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
        +
        @@ -98,7 +98,7 @@

        - Swift 编程语言 + 这一次，让中国和世界同步

        @@ -119,7 +119,7 @@
      • - Introduction + 序
        • @@ -331,7 +331,7 @@
      • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,22 +587,28 @@
        -
        +
        -

        类和结构体

        +
        +

        翻译：JaySurplus

        +

        校对：sg552

        +
        +

        类和结构体

        本页包含内容：

        类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照对于常量，变量以及函数所规定的语法规则来定义属性和添加方法。

        与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。

        +

        注意：

        通常一个类的实例被称为对象。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用实例而不是对象。

        +

        类和结构体对比

        Swift 中类和结构体有很多共同点。共同处在于：

          @@ -613,7 +619,7 @@
        • 通过扩展以增加默认实现的功能
        • 符合协议以对某类提供标准功能
        -

        更多信息请参见 属性，方法，下标，初始化，扩展，和协议。

        +

        更多信息请参见 属性，方法，下标，初始过程，扩展，和协议。

        与结构体相比，类还有如下的附加功能：

        • 继承允许一个类继承另一个类的特征
          • @@ -623,6 +629,7 @@

        更多信息请参见继承，类型转换，初始化，和自动引用计数。

        +

        注意：

        结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。

        定义

        @@ -634,7 +641,8 @@ struct SomeStructure { // structure definition goes here }
        -

        在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的Swift 类型。因此请使用 UpperCamelCase 这种方式来命名（如 SomeClass 和SomeStructure等），以便符合标准Swift 类型的大写命名风格（如String，Int和Bool）。相反的，请使用lowerCamelCase这种方式为属性和方法命名（如framerate和incrementCount），以便和类区分。

        +

        注意：

        +

        在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 UpperCamelCase 这种方式来命名（如 SomeClass 和SomeStructure等），以便符合标准Swift 类型的大写命名风格（如String，Int和Bool）。相反的，请使用lowerCamelCase这种方式为属性和方法命名（如framerate和incrementCount），以便和类区分。

        以下是定义结构体和定义类的示例：

        struct Resolution {
@@ -654,44 +662,46 @@ class VideoMode {
 
        生成结构体和类实例的语法非常相似：
        
 
        let someResolution = Resolution()
 let someVideoMode = VideoMode()
-
        结构体和类都使用初始化器语法来生成新的实例。初始化器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如Resolution()或VideoMode()。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。Initialization章节会对类和结构体的初始化进行更详细的讨论。
        
+

        结构体和类都使用初始化器语法来生成新的实例。初始化器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如Resolution()或VideoMode()。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。构造过程章节会对类和结构体的初始化进行更详细的讨论。

        属性访问

        通过使用点语法（dot syntax）,你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：

        println("The width of someResolution is \(someResolution.width)")
-// prints "The width of someResolution is 0"
+// 输出 "The width of someResolution is 0"

        在上面的例子中，someResolution.width引用someResolution的width属性，返回width的初始值0。

        你也可以访问子属性，如何VideoMode中Resolution属性的width属性：

        println("The width of someVideoMode is \(someVideoMode.resolution.width)")
-// prints "The width of someVideoMode is 0"
+// 输出 "The width of someVideoMode is 0"

        你也可以使用点语法为属性变量赋值：

        someVideoMode.resolution.width = 12880
 println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
-// prints "The width of someVideoMode is now 1280"
+// 输出 "The width of someVideoMode is now 1280"
        -

        与Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了someVideoMode中resolution属性的width这个子属性，以上操作并不需要从新设置resolution属性。

        +

        注意：

        +

        与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了someVideoMode中resolution属性的width这个子属性，以上操作并不需要从新设置resolution属性。

        结构体类型的成员逐一初始化器

        //Memberwise Initializers for structure Types

        所有结构体都有一个自动生成的成员逐一初始化器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一初始化器之中：

        let vga = resolution（width:640, heigth: 480）
-

        与结构体不同，类实例没有默认的成员逐一初始化器。Initialization章节会对初始化器进行更详细的讨论。

        -

        结构体和枚举是值类型

        +

        与结构体不同，类实例没有默认的成员逐一初始化器。构造过程章节会对初始化器进行更详细的讨论。

        +

        +

        结构体和枚举是值类型

        值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。

        -

        在之前的章节中，我们已经大量使用了值类型。实际上，在Swift 中，所有的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)，都是值类型，并且都是以结构体的形式在后台所实现。

        -

        在Swift中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。

        +

        在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)，都是值类型，并且都是以结构体的形式在后台所实现。

        +

        在 Swift 中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。

        请看下面这个示例，其使用了前一个示例中Resolution结构体：

        let hd = Resolution(width: 1920, height: 1080)
 var cinema = hd
-

        在以上示例中，声明了一个名为hd的常量，其值为一个初始化为全高清视频分辨率(1920像素宽，1080像素高)的Resolution实例。

        +

        在以上示例中，声明了一个名为hd的常量，其值为一个初始化为全高清视频分辨率(1920 像素宽，1080 像素高)的Resolution实例。

        然后示例中又声明了一个名为cinema的变量，其值为之前声明的hd。因为Resolution是一个结构体，所以cinema的值其实是hd的一个拷贝副本，而不是hd本身。尽管hd和cinema有着相同的宽(width)和高(height)属性，但是在后台中，它们是两个完全不同的实例。

        -

        下面，为了符合数码影院放映的需求(2048像素宽，1080像素高)，cinema的width属性需要作如下修改：

        +

        下面，为了符合数码影院放映的需求(2048 像素宽，1080 像素高)，cinema的width属性需要作如下修改：

        cinema.width = 2048

        这里，将会显示cinema的width属性确已改为了2048：

        println("cinema is now  \(cinema.width) pixels wide")
-// prints "cinema is now 2048 pixels wide"
+// 输出 "cinema is now 2048 pixels wide"

        然而，初始的hd实例中width属性还是1920：

        println("hd is still \(hd.width    ) pixels wide")
-// prints "hd is still 1920 pixels wide"
+// 输出 "hd is still 1920 pixels wide"

        在将hd赋予给cinema的时候，实际上是将hd中所储存的值(values)进行拷贝，然后将拷贝的数据储存到新的cinema实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将cinema的width修改为2048并不会影响hd中的宽(width)。

        枚举也遵循相同的行为准则：

        enum CompassPoint {
@@ -703,9 +713,10 @@ currentDirection = .East
 if rememberDirection == .West {
     println("The remembered direction is still .West")
 }
-// prints "The remembered direction is still .West"
+// 输出 "The remembered direction is still .West"

        上例中rememberedDirection被赋予了currentDirection的值(value)，实际上它被赋予的是值(value)的一个拷贝。赋值过程结束后再修改currentDirection的值并不影响rememberedDirection所储存的原始值(value)的拷贝。

        -

        类是引用类型

        +

        +

        类是引用类型

        与值类型不同，引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的并不是其拷贝。因此，引用的是已存在的实例本身而不是其拷贝。

        请看下面这个示例，其使用了之前定义的VideoMode类：

        let tenEighty = VideoMode()
@@ -720,7 +731,7 @@ alsoTenEighty.frameRate = 30.0

        因为类是引用类型，所以tenEight和alsoTenEight实际上引用的是相同的VideoMode实例。换句话说，它们只是同一个实例的两种叫法。

        下面，通过查看tenEighty的frameRate属性，我们会发现它正确的显示了基本VideoMode实例的新帧率，其值为30.0：

        println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
-// prints "The frameRate property of theEighty is now 30.0"
+// 输出 "The frameRate property of theEighty is now 30.0"

        需要注意的是tenEighty和alsoTenEighty被声明为常量(constants)而不是变量。然而你依然可以改变tenEighty.frameRate和alsoTenEighty.frameRate,因为这两个常量本身不会改变。它们并不储存这个VideoMode实例，在后台仅仅是对VideoMode实例的引用。所以，改变的是被引用的基础VideoMode的frameRate参数，而不改变常量的值。

        恒等运算符

        因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。(对于结构体和枚举来说，这并不成立。因为它们作值类型，在被赋予到常量，变量或者传递到函数时，总是会被拷贝。)

        @@ -733,16 +744,17 @@ alsoTenEighty.frameRate = 30.0 
        if tenEighty === alsoTenTighty {
     println("tenTighty and alsoTenEighty refer to the same Resolution instance.")
 }
-//prints "tenEighty and alsoTenEighty refer to the same Resolution instance."
+//输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."

        请注意“等价于”(用三个等号表示，===) 与“等于”(用两个等号表示，==)的不同：

        • “等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。
        • “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
        -

        当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节Equivalence Operators中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。

        +

        当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节运算符函数(Operator Functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。

        指针

        -

        如果你有C，C++或者Objective-C语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。

        -

        类和结构体的选择

        +

        如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。

        +

        +

        类和结构体的选择

        在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。

        然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。

        按照通用的准则，当符合一条或多条以下条件时，请考虑构建结构体：

        @@ -759,15 +771,17 @@ alsoTenEighty.frameRate = 30.0
      • 三维坐标系内一点，封装x，y和z属性，三者均为Double类型。

      在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。

      -

      集合(Collection)类型的赋值和拷贝行为

      +

      +

      集合(Collection)类型的赋值和拷贝行为

      Swift 中数组(Array)和字典(Dictionary)类型均以结构体的形式实现。然而当数组被赋予一个常量或变量，或被传递给一个函数或方法时，其拷贝行为与字典和其它结构体有些许不同。

      以下对数组和结构体的行为描述与对NSArray和NSDictionary的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。NSArray和NSDictionary实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。

      -

      以下是对于数组，字典，字符串和其它值的拷贝的描述。 +

      注意：

      +

      以下是对于数组，字典，字符串和其它值的拷贝的描述。 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在Swift 的后台中，只有确有必要，实际(actual)拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。(实际赋值由系统管理优化)

      字典类型的赋值和拷贝行为

      -

      无论何时将一个字典实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节Structures and Enumerations Are Value Types中将会对此过程进行详细介绍。

      +

      无论何时将一个字典实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节结构体和枚举是值类型中将会对此过程进行详细介绍。

      如果字典实例中所储存的键(keys)和/或值(values)是值类型(结构体或枚举)，当赋值或调用发生时，它们都会被拷贝。相反，如果键(keys)和/或值(values)是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。字典的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。

      下面的示例定义了一个名为ages的字典，其中储存了四个人的名字和年龄。ages字典被赋予了一个名为copiedAges的新变量，同时ages在赋值的过程中被拷贝。赋值结束后，ages和copiedAges成为两个相互独立的字典。

      var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
@@ -776,11 +790,11 @@ var copiedAges = ages
 
      我们可以通过改变一个字典中的年龄值(age value)，检查另一个字典中所对应的值，来证明ages字典确实是被拷贝了。如果在copiedAges字典中将Peter的值设为24，那么ages字典仍然会返回修改前的值23：
      
 
      copiedAges["Peter"] = 24
 println(ages["Peter"])
-// prints "23"
+// 输出 "23"
 
      数组的赋值和拷贝行为
      
 
      在Swift 中，数组(Arrays)类型的赋值和拷贝行为要比字典(Dictionary)类型的复杂的多。当操作数组内容时，数组(Array)能提供接近C语言的的性能，并且拷贝行为只有在必要时才会发生。
      
 
      如果你将一个数组(Array)实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容不会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。
      
-
      对数组来说，拷贝行为仅仅当操作有可能修改数组长度时才会发生。这种行为包括了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节Assignment and Copy Behavior for Dictionaries。
      
+
      对数组来说，拷贝行为仅仅当操作有可能修改数组长度时才会发生。这种行为包括了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types。
      
 
      下面的示例将一个整数(Int)数组赋给了一个名为a的变量，继而又被赋给了变量b和c：
      
 
      var a = [1, 2, 3]
 var b = a
@@ -801,7 +815,7 @@ println(b[0])
 println(c[0])
 // 42
 
      然而，当你给a附加新元素时，数组的长度会改变。
-当附加元素这一事件发生时，Swift 语言会创建这个数组的一个拷贝。从此以后，a将会是原数组的一个独立拷贝。
      
+当附加元素这一事件发生时，Swift 会创建这个数组的一个拷贝。从此以后，a将会是原数组的一个独立拷贝。
      
 
      拷贝发生后，如果再修改a中元素值的话，a将会返回与b，c不同的结果，因为后两者引用的是原来的数组：
      
 
      a.append(4)
 a[0] = 777
@@ -833,14 +847,14 @@ println(c[0])
     println("b and c now refer to two independent sets of array elements.")
 }
 
-// prints "b and c now refer totwo independent sets of array elements."
+// 输出 "b and c now refer totwo independent sets of array elements."
 
      此外，我们还可以使用恒等运算符来判定两个子数组是否共用相同的元素。下面这个示例中，比较了b的两个相等的子数组，并且确定了这两个子数组都引用相同的元素：
      
 
      if b[0...1] === b[0...1] {
     println("These two subarrays share the same elements.")
 } else {
     println("These two subarrays do not share the same elements.")
 }
-// prints "These two subarrays share the same elements."
+// 输出 "These two subarrays share the same elements."
 
      强制复制数组
      
 
      我们通过调用数组的copy方法进行强制显性复制。这个方法对数组进行了浅拷贝(shallow copy),并且返回一个包含此拷贝的新数组。
      
 
      下面这个示例中定义了一个names数组，其包含了七个人名。还定义了一个copiedNames变量，用以储存在names上调用copy方法所返回的结果：
      
@@ -849,8 +863,9 @@ var copiedNames = names.copy

      我们可以通过修改一个数组中某元素，并且检查另一个数组中对应元素的方法来判定names数组确已被复制。如果你将copiedNames中第一个元素从"Mohsen"修改为"Mo",则names数组返回的仍是拷贝发生前的"Mohsen"：

      copiedName[0] = "Mo"
 println(name[0])
-// prints "Mohsen"
+// 输出 "Mohsen"
      +

      注意：

      如果你仅需要确保你对数组的引用是唯一引用，请调用unshare方法，而不是copy方法。unshare方法仅会在确有必要时才会创建数组拷贝。copy方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。

      @@ -898,6 +913,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/10_Properties.html b/chapter2/10_Properties.html index 97931241..a509a373 100644 --- a/chapter2/10_Properties.html +++ b/chapter2/10_Properties.html @@ -5,12 +5,12 @@ - 属性 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
      +
      @@ -98,7 +98,7 @@

      - Swift 编程语言 + 这一次，让中国和世界同步

      @@ -119,7 +119,7 @@
    • - Introduction + 序
      • @@ -331,7 +331,7 @@
    • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,9 +587,13 @@
      -
      +
      -

      属性 (Properties)

      +
      +

      翻译：shinyzhu

      +

      校对：pp-prog

      +
      +

      属性 (Properties)

      本页包含内容：

      -

      属性将值跟特定的类、结构或枚举关联。一种是存储属性，把常量或变量的值作为实例的一部分，一种是计算属性，它计算一个值。计算属性可以用于类、结构和枚举里，存储属性只能用于类和结构。

      -

      存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类属性。

      +

      属性将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，计算属性计算（而不是存储）一个值。计算属性可以用于类、结构体和枚举里，存储属性只能用于类和结构体。

      +

      存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类型属性。

      另外，还可以定义属性监视器来监控属性值的变化，以此来触发一个自定义的操作。属性监视器可以添加到自己写的存储属性上，也可以添加到从父类继承的属性上。

      存储属性

      -

      简单来说，一个存储属性就是一个特定类型实例里表示常量或变量的部分，存储属性可以是变量存储属性（用关键字var定义），也可以是常量存储属性（用关键字let定义）。

      -

      可以在定义存储属性的时候指定默认值，详见默认属性值一节。也可以在初始化阶段设置或修改存储属性的值，甚至修改常量存储属性的值，详见在初始化阶段修改常量存储属性一节。

      -

      下面的例子定义了一个名为FixedLengthRange的结构体，表示一个在创建后无法修改整数范围的类型：

      +

      简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量，存储属性可以是变量存储属性（用关键字var定义），也可以是常量存储属性（用关键字let定义）。

      +

      可以在定义存储属性的时候指定默认值，请参考构造过程一章的默认属性值一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考构造过程一章的在初始化阶段修改常量存储属性一节。

      +

      下面的例子定义了一个名为FixedLengthRange的结构体，他描述了一个在创建后无法修改值域宽度的区间：

      struct FixedLengthRange {
     var firstValue: Int
     let length: Int
 }
 var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
-// the range represents integer values 0, 1, and 2
+// 该区间表示整数0，1，2
 rangeOfThreeItems.firstValue = 6
-// the range now represents integer values 6, 7, and 8
-

      FixedLengthRange的实例包含一个名为firstValue的变量存储属性和一个名为length的常量存储属性。在上面的例子中，length在创建实例的时候被赋值，因为它是一个常量存储属性，所以无法修改它的值。

      +// 该区间现在表示整数6，7，8 +

      FixedLengthRange的实例包含一个名为firstValue的变量存储属性和一个名为length的常量存储属性。在上面的例子中，length在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的值。

      常量和存储属性

      如果创建了一个结构体的实例并赋值给一个常量，则无法修改实例的任何属性，即使定义了变量存储属性：

      let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
-// this range represents integer values 0, 1, 2, and 3
+// 该区间表示整数0，1，2，3
 rangeOfFourItems.firstValue = 6
-// this will report an error, even thought firstValue is a variable property
-

      因为rangeOfFourItems声明成了常量（用let关键字），即使firstValue是一个变量属性，也无法再修改属性它的值。

      +// 尽管firstValue诗歌变量属性，这里还是会报错 +

      因为rangeOfFourItems声明成了常量（用let关键字），即使firstValue是一个变量属性，也无法再修改它了。

      这种行为是由于结构体（struct）属于值类型。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。

      属于引用类型的类（class）则不一样，把一个引用类型的实例赋给一个常量后，仍然可以修改实例的变量属性。

      延迟存储属性

      -

      延迟存储属性是指当第一次被调用的时候才有初始值的属性。在属性声明前使用@lazy特性来表示一个延迟存储属性。

      +

      延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用@lazy来标示一个延迟存储属性。

      -

      注意

      -

      必须将延迟存储属性声明成变量（使用var关键字），因为可能在实例构造完成之前属性的值无法得到。常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。

      +

      注意：

      +

      必须将延迟存储属性声明成变量（使用var关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。

      延迟属性很有用，当属性的值依赖于在实例的构造过程结束前无法知道具体值的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。

      -

      下面复合类的例子使用了延迟存储属性来避免不必要的初始化。例子中定义了DataImporter和DataManager两个类，下面是部分代码：

      +

      下面的例子使用了延迟存储属性来避免复杂类的不必要的初始化。例子中定义了DataImporter和DataManager两个类，下面是部分代码：

      class DataImporter {
     /*
-    DataImporter is a class to import data from an external file.
-    The class is assumed to take a non-trivial amount of time to initialize.
+    DataImporter 是一个将外部文件中的数据导入的类。
+    这个类的初始化会消耗不少时间。
     */
     var fileName = "data.txt"
-    // the DataImporter class would provide data importing functionality here
+    // 这是提供数据导入功能
 }
 
 class DataManager {
     @lazy var importer = DataImporter()
     var data = String[]()
-    // the DataManager class would provide data management functionality here
+    // 这是提供数据管理功能
 }
 
 let manager = DataManager()
 manager.data += "Some data"
 manager.data += "Some more data"
-// the DataImporter instance for the importer property has not yet been created
+// DataImporter 实例的 importer 属性还没有被创建

      DataManager类包含一个名为data的存储属性，初始值是一个空的字符串（String）数组。虽然没有写出全部代码，DataManager类的目的是管理和提供对这个字符串数组的访问。

      -

      DataManager的一个功能是从文件导入数据，该功能由DataImporter类提供，它需要一定的时间来处理。因为它需要在实例化之后打开文件、读取文件内容到内存。

      -

      DataManager也可以不从文件中导入数据，所以当DataManager的实例被创建时，就没有必要创建一个DataImporter的实例。同时，更有意义的是当用到DataImporter的时候才去创建它。

      -

      由于使用了@lazy特性（Attribute），importer属性只有在第一次被访问的时候才被创建。比如访问它的属性fileName时：

      +

      DataManager的一个功能是从文件导入数据，该功能由DataImporter类提供，DataImporter需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。

      +

      DataManager也可能不从文件中导入数据。所以当DataManager的实例被创建时，没必要创建一个DataImporter的实例，更明智的是当用到DataImporter的时候才去创建它。

      +

      由于使用了@lazy，importer属性只有在第一次被访问的时候才被创建。比如访问它的属性fileName时：

      println(manager.importer.fileName)
-// the DataImporter instance for the importer property has now been created
-// prints "data.txt”
+// DataImporter 实例的 importer 属性现在被创建了
+// 输出 "data.txt”

      存储属性和实例变量

      如果您有过 Objective-C 经验，应该知道有两种方式在类实例存储值和引用。对于属性来说，也可以使用实例变量作为属性值的后端存储。

      Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。 -一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方定义。

      +一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。

      计算属性

      除存储属性外，类、结构体和枚举可以定义计算属性，计算属性不直接存储值，而是提供一个 getter 来获取值，一个可选的 setter 来间接设置其他属性或变量的值。

      @@ -695,17 +699,17 @@ var square = Rect(origin: Point(x: 0.0, y: 0.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))") -// prints "square.origin is now at (10.0, 10.0)” +// 输出 "square.origin is now at (10.0, 10.0)”

      这个例子定义了 3 个几何形状的结构体：

      • Point封装了一个(x, y)的坐标
      • Size封装了一个width和height
      • Rect表示一个有原点和尺寸的矩形
      -

      Rect也提供了一个名为center的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的Point来保存。Rect的计算属性center提供了自定义的getter和setter来获取和设置矩形的中心点，就像它有一个存储属性一样。

      +

      Rect也提供了一个名为center的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的Point来保存。Rect的计算属性center提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。

      例子中接下来创建了一个名为square的Rect实例，初始值原点是(0, 0)，宽度高度都是10。如图所示蓝色正方形。

      -

      square的center属性可以通过点运算符（square.center）来访问，这会调用getter来获取属性的值。跟直接返回已经存在的值不同，getter实际上通过计算然后返回一个新的Point实例表示square的中心点。如代码所示，它正确返回了中心点(5, 5)。

      -

      center属性之后被设置了一个新的值(15, 15)，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性center的值会调用setter来修改属性origin的x和y的值，从而实现移动正方形到新的位置。

      +

      square的center属性可以通过点运算符（square.center）来访问，这会调用 getter 来获取属性的值。跟直接返回已经存在的值不同，getter 实际上通过计算然后返回一个新的Point来表示square的中心点。如代码所示，它正确返回了中心点(5, 5)。

      +

      center属性之后被设置了一个新的值(15, 15)，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性center的值会调用 setter 来修改属性origin的x和y的值，从而实现移动正方形到新的位置。

      Computed Properties sample

      便捷 setter 声明

      @@ -729,7 +733,7 @@ println("square.origin is now at (\(square.origin.x), \(square.origin.y))&q

      只读计算属性

      只有 getter 没有 setter 的计算属性就是只读计算属性。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。

      -

      注意

      +

      注意：

      必须使用var关键字定义计算属性，包括只读计算属性，因为他们的值不是固定的。let关键字只用来声明常量属性，表示初始化后再也无法修改的值。

      只读计算属性的声明可以去掉get关键字和花括号：

      @@ -741,15 +745,14 @@ println("square.origin is now at (\(square.origin.x), \(square.origin.y))&q } let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0) println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)") -// prints "the volume of fourByFiveByTwo is 40.0" -

      这个例子定义了一个名为Cuboid的结构体，表示三维空间的立方体，包含width、height和depth属性，还有一个名为volume的只读计算属性用来返回立方体的体积，设置volume的值毫无意义，因为无法确定width、height和depth的值。

      -

      尽管如此，Cuboid提供一个只读计算属性来让外部用户直接获取体积是很有用的。

      +// 输出 "the volume of fourByFiveByTwo is 40.0" +

      这个例子定义了一个名为Cuboid的结构体，表示三维空间的立方体，包含width、height和depth属性，还有一个名为volume的只读计算属性用来返回立方体的体积。设置volume的值毫无意义，因为通过width、height和depth就能算出volume。然而，Cuboid提供一个只读计算属性来让外部用户直接获取体积是很有用的。

      属性监视器

      属性监视器监控和响应属性值的变化，每次属性被设置值的时候都会调用属性监视器，甚至新的值和现在的值相同的时候也不例外。

      -

      可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载详见重载一节。

      +

      可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载请参考继承一章的重载。

      -

      注意

      +

      注意：

      不需要为无法重载的计算属性添加属性监视器，因为可以通过 setter 直接监控和响应值的变化。

      可以为属性添加如下的一个或全部监视器：

      @@ -760,7 +763,7 @@ println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")

      willSet监视器会将新的属性值作为固定参数传入，在willSet的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称newValue表示。

      类似地，didSet监视器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名oldValue。

      -

      注意

      +

      注意：

      willSet和didSet监视器在属性初始化过程中不会被调用，他们只会当属性的值在初始化之外的地方被设置时被调用。

      这里是一个willSet和didSet的实际例子，其中定义了一个名为StepCounter的类，用来统计当人步行时的总步数，可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。

      @@ -791,67 +794,67 @@ stepCounter.totalSteps = 896

      例子中的willSet监视器将表示新值的参数自定义为newTotalSteps，这个监视器只是简单的将新的值输出。

      didSet监视器在totalSteps的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。didSet没有提供自定义名称，所以默认值oldValue表示旧值的参数名。

      -

      注意

      +

      注意：

      如果在didSet监视器里为属性赋值，这个值会替换监视器之前设置的值。

      全局变量和局部变量

      -

      计算属性和属性监视器所描述的模式也可以用于全局变量和局部变量，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。

      +

      计算属性和属性监视器所描述的模式也可以用于全局变量和局部变量，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。

      前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。

      另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义监视器，计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。

      -

      注意

      +

      注意：

      全局的常量或变量都是延迟计算的，跟延迟存储属性相似，不同的地方在于，全局的常量或变量不需要标记@lazy特性。

      局部范围的常量或变量不会延迟计算。

      -

      类属性

      +

      类型属性

      实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。

      -

      也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是类属性。

      -

      类属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。

      -

      对于值类型（指结构体和枚举）可以定义存储型和计算型类属性，对于类（class）则只能定义计算型类属性。

      -

      值类型的存储型类属性可以是变量或常量，计算型类属性跟实例的计算属性一样定义成变量属性。

      +

      也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是类型属性。

      +

      类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。

      +

      对于值类型（指结构体和枚举）可以定义存储型和计算型类型属性，对于类（class）则只能定义计算型类型属性。

      +

      值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样定义成变量属性。

      -

      注意

      -

      跟实例的存储属性不同，必须给存储型类属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类属性赋值。

      +

      注意：

      +

      跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。

      -

      类属性语法

      -

      在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上global关键字。在 Swift 编程语言中，类属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。

      -

      使用关键字static来定义值类型的类属性，关键字class来为类（class）定义类属性。下面的例子演示了存储型和计算型类属性的语法：

      +

      类型属性语法

      +

      在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上global关键字。在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。

      +

      使用关键字static来定义值类型的类型属性，关键字class来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法：

      struct SomeStructure {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
 enum SomeEnumeration {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
 class SomeClass {
     class var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
      -

      注意

      -

      例子中的计算型类属性是只读的，但也可以定义可读可写的计算型类属性，跟实例计算属性的语法类似。

      +

      注意：

      +

      例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。

      -

      获取和设置类属性的值

      -

      跟实例的属性一样，类属性的访问也是通过点运算符来进行，但是，类属性是通过类型本身来获取和设置，而不是通过实例。比如：

      +

      获取和设置类型属性的值

      +

      跟实例的属性一样，类型属性的访问也是通过点运算符来进行，但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：

      println(SomeClass.computedTypeProperty)
-// prints "42"
+// 输出 "42"
 
 println(SomeStructure.storedTypeProperty)
-// prints "Some value."
+// 输出 "Some value."
 SomeStructure.storedTypeProperty = "Another value."
 println(SomeStructure.storedTypeProperty)
-// prints "Another value.”
-

      下面的例子定义了一个结构体，使用两个存储型类属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。

      +// 输出 "Another value.” +

      下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。

      后面的图表展示了如何联合使用两个声道来表示一个立体声的声音电平值。当声道的电平值是 0，没有一个灯会亮；当声道的电平值是 10，所有灯点亮。本图中，左声道的电平是 9，右声道的电平是 7。

      Static Properties VUMeter

      上面所描述的声道模型使用AudioChannel结构体来表示：

      @@ -861,18 +864,18 @@ println(SomeStructure.storedTypeProperty) var currentLevel: Int = 0 { didSet { if currentLevel > AudioChannel.thresholdLevel { - // cap the new audio level to the threshold level + // 将新电平值设置为阀值 currentLevel = AudioChannel.thresholdLevel } if currentLevel > AudioChannel.maxInputLevelForAllChannels { - // store this as the new overall maximum input level + // 存储当前电平值作为新的最大输入电平 AudioChannel.maxInputLevelForAllChannels = currentLevel } } } } -

      结构AudioChannel定义了 2 个存储型类属性来实现上述功能。第一个是thresholdLevel，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。

      -

      第二个类属性是变量存储型属性maxInputLevelForAllChannels，它用来表示所有AudioChannel实例的电平值的最大值，初始值是 0。

      +

      结构AudioChannel定义了 2 个存储型类型属性来实现上述功能。第一个是thresholdLevel，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。

      +

      第二个类型属性是变量存储型属性maxInputLevelForAllChannels，它用来表示所有AudioChannel实例的电平值的最大值，初始值是 0。

      AudioChannel也定义了一个名为currentLevel的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。

      属性currentLevel包含didSet属性监视器来检查每次新设置后的属性值，有如下两个检查：

        @@ -880,24 +883,24 @@ println(SomeStructure.storedTypeProperty)
      • 如果修正后的currentLevel值大于任何之前任意AudioChannel实例中的值，属性监视器将新值保存在静态属性maxInputLevelForAllChannels中。
      -

      注意

      -

      在第一个检查过程中，didSet属性监视器将currentLevel设置成了不同的值，但这不会再次调用属性监视器。

      +

      注意：

      +

      在第一个检查过程中，didSet属性监视器将currentLevel设置成了不同的值，但这时不会再次调用属性监视器。

      -

      可以使用结构AudioChannel来创建表示立体声系统的两个声道leftChannel和rightChannel：

      +

      可以使用结构体AudioChannel来创建表示立体声系统的两个声道leftChannel和rightChannel：

      var leftChannel = AudioChannel()
 var rightChannel = AudioChannel()
-

      如果将左声道的电平设置成 7，类属性maxInputLevelForAllChannels也会更新成 7：

      +

      如果将左声道的电平设置成 7，类型属性maxInputLevelForAllChannels也会更新成 7：

      leftChannel.currentLevel = 7
 println(leftChannel.currentLevel)
-// prints "7"
+// 输出 "7"
 println(AudioChannel.maxInputLevelForAllChannels)
-// prints "7”
+// 输出 "7"

      如果试图将右声道的电平设置成 11，则会将右声道的currentLevel修正到最大值 10，同时maxInputLevelForAllChannels的值也会更新到 10：

      rightChannel.currentLevel = 11
 println(rightChannel.currentLevel)
-// prints "10"
+// 输出 "10"
 println(AudioChannel.maxInputLevelForAllChannels)
-// prints "10”
+// 输出 "10"
      @@ -943,6 +946,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/11_Methods.html b/chapter2/11_Methods.html index 42b16910..86aa2d71 100644 --- a/chapter2/11_Methods.html +++ b/chapter2/11_Methods.html @@ -5,12 +5,12 @@ - 方法 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
      +
      @@ -98,7 +98,7 @@

      - Swift 编程语言 + 这一次，让中国和世界同步

      @@ -119,7 +119,7 @@
    • - Introduction + 序
      • @@ -331,7 +331,7 @@
    • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,16 +587,26 @@
      -
      +
      -

      方法（Methods）

      +
      +

      翻译：pp-prog

      +

      校对：地

      +
      +

      方法（Methods）

      -

      方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型自身相关联。类型方法与Objective-C中的类方法(class methods)相似。

      -

      在Swift中,结构体和枚举能够定义方法；事实上这是Swift与C/Objective-C的主要区别之一。在Objective-C中,类是唯一能定义方法的类型。但在Swift中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型(类/结构体/枚举)上定义方法。

      -

      实例方法(Instance Methods)

      -

      实例方法是某个特定类、结构体或者枚举类型的实例的方法。实例方法支撑实例的功能: 或者提供方法,以访问和修改实例属性;或者提供与实例的目的相关的功能。实例方法的语法与函数完全一致，你可以参考函数。

      +

      本页包含内容：

      + +

      方法是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。

      +

      结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。

      +

      +

      实例方法(Instance Methods)

      +

      实例方法是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见函数。

      实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。

      -

      下面的例子，定义一个很简单的类Counter，Counter能被用来对一个动作发生的次数进行计数:

      +

      下面的例子，定义一个很简单的类Counter，Counter能被用来对一个动作发生的次数进行计数：

      class Counter {
   var count = 0
   func increment() {
@@ -616,47 +626,50 @@
 
    • reset将计数器重置为0。
      •

    Counter这个类还声明了一个可变属性count，用它来保持对当前计数器值的追踪。

    -

    和调用属性一样，用点语法(dot syntax)调用实例方法:

    +

    和调用属性一样，用点语法（dot syntax）调用实例方法：

     let counter = Counter()
- // the initial counter value is 0
+ // 初始计数值是0
  counter.increment()
- // the counter's value is now 1
+ // 计数值现在是1
  counter.incrementBy(5)
- // the counter's value is now 6
+ // 计数值现在是6
  counter.reset()
- // the counter's value is now 0
-

    方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)

    -

    函数参数可以同时有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用),参考函数的外部参数名。方法参数也一样(因为方法就是函数，只是这个函数与某个类型相关联了)。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。

    -

    Swift中的方法和Objective-C中的方法极其相似。像在Objective-C中一样，Swift中方法的名称通常用一个介词指向方法的第一个参数，比如：with,for,by等等。前面的Counter类的例子中incrementBy方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。Swift这种方法命名约定让书写代码更容易了,因为Swift依靠对方法参数不同的默认处理方式，而不是靠函数参数，来实现方法命名。

    -

    具体来说，Swift默认仅给方法的第一个参数名称一个局部参数名称;但是默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，这与你在写Objective-C的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。

    -

    看看下面这个Counter的替换版本（它定义了一个更复杂的incrementBy方法）：

    + // 计数值现在是0 +

    +

    方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)

    +

    函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见函数的外部参数名。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。

    +

    Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：with，for，by等等。前面的Counter类的例子中incrementBy方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。

    +

    具体来说，Swift 默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。

    +

    看看下面这个Counter的另一个版本（它定义了一个更复杂的incrementBy方法）：

    class Counter {
   var count: Int = 0
   func incrementBy(amount: Int, numberOfTimes: Int) {
     count += amount * numberOfTimes
   }
 }
-

    incrementBy方法有两个参数： amount和numberOfTimes。默认地，Swift只把amount当作一个局部名称，但是把numberOfTimes即看作本地名称又看作外部名称。下面调用这个方法：

    +

    incrementBy方法有两个参数： amount和numberOfTimes。默认情况下，Swift 只把amount当作一个局部名称，但是把numberOfTimes即看作局部名称又看作外部名称。下面调用这个方法：

    let counter = Counter()
 counter.incrementBy(5, numberOfTimes: 3)
 // counter value is now 15
-

    你不必为第一个参数值再定义一个外部变量名：因为从函数名incrementBy已经能很清楚地看出它的目的/作用。但是第二个参数，就要被一个外部参数名称所限定,以便在方法被调用时让他目的/作用明确。

    -

    这种默认的行为能够有效的处理方法，比如你在参数numberOfTimes前写了个井号( # )时:

    +

    你不必为第一个参数值再定义一个外部变量名：因为从函数名incrementBy已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。

    +

    这种默认的行为能够有效的处理方法（method）,类似于在参数numberOfTimes前写一个井号（#）：

    func incrementBy(amount: Int, #numberOfTimes: Int) {
  count += amount * numberOfTimes
 }
-

    这种默认行为使上面代码意味着：在Swift中定义方法使用了与Objective-C同样的语法风格，并且方法将以自然表达式的方式被调用。

    +

    这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。

    +

    修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)

    -

    有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称;你也可以用一个hash符号作为第一个参数的前缀，把这个局部名称呢更作为外部名称。

    -

    相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，你可以通过使用下划线(_)作为该参数的显式外部名称来覆盖默认行为。

    -

    self属性(The self Property)

    +

    有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（#）作为第一个参数的前缀来把这个局部名称当作外部名称使用。

    +

    相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（_）作为该参数的显式外部名称，这样做将覆盖默认行为。

    +

    +

    self属性(The self Property)

    类型的每一个实例都有一个隐含属性叫做self，self完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的self属性来引用当前实例。

    上面例子中的increment方法还可以这样写：

    func increment() {
   self.count++
 }
-

    实际上，你不必在你的代码里面经常写self。不论何时，在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写self，Swift假定你是指当前实例的属性或者方法。这种假定在上面的Counter中已经示范了：Counter中的三个实例方法中都使用的是count(而不是self.count)

    -

    这条规则的主要例外发生在当实例方法的某个参数名称与实例的某个属性名称相同时。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更恰当(被限定更严格)的方式。你可以使用self属性来区分参数名称和属性名称。

    +

    实际上，你不必在你的代码里面经常写self。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写self，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的Counter中已经示范了：Counter中的三个实例方法中都使用的是count（而不是self.count）。

    +

    使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用self属性来区分参数名称和属性名称。

    下面的例子中，self消除方法参数x和实例属性x之间的歧义：

    struct Point {
   var x = 0.0, y = 0.0
@@ -668,12 +681,13 @@ 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")
 }
-// prints "This point is to the right of the line where x == 1.0"
-

    如果不使用self前缀，Swift就认为两次使用的x都指的是名称为x的函数参数。

    +// 输出 "This point is to the right of the line where x == 1.0"（这个点在x等于1.0这条线的右边） +

    如果不使用self前缀，Swift 就认为两次使用的x都指的是名称为x的函数参数。

    +

    在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)

    结构体和枚举是值类型。一般情况下，值类型的属性不能在它的实例方法中被修改。

    -

    但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择变异(mutating)这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时都会回写到原始结构。方法还可以给它隐含的self属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。

    -

    要变异方法, 将关键字mutating 放到方法的func关键字之前就可以了：

    +

    但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择变异(mutating)这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的self属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。

    +

    要使用变异方法， 将关键字mutating 放到方法的func关键字之前就可以了：

    struct Point {
   var x = 0.0, y = 0.0
   mutating func moveByX(deltaX: Double, y deltaY: Double) {
@@ -684,13 +698,14 @@ if somePoint.isToTheRightOfX(1.0) {
 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))")
-// prints "The point is now at (3.0, 4.0)"
-

    上面的Point结构体定义了一个变异方法(mutating method)moveByX，moveByX用来移动一个point。moveByX方法在被调用时修改了这个point,而不是返回一个新的point。方法定义时加上mutating关键字,这才让方法可以修改值类型的属性了。

    -

    注意：不能在结构体类型的常量上调用变异方法,因为常量的属性不能被改变,就算你想改变的是常量的可变属性也不行，参考存储属性和实例变量

    +// 输出 "The point is now at (3.0, 4.0)" +

    上面的Point结构体定义了一个变异方法（mutating method）moveByX，moveByX用来移动点。moveByX方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上mutating关键字,这才让方法可以修改值类型的属性。

    +

    注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见存储属性和实例变量

    let fixedPoint = Point(x: 3.0, y: 3.0)
 fixedPoint.moveByX(2.0, y: 3.0)
 // this will report an error
-

    在变异方法中给self赋值(Assigning to self Within a Mutating Method)

    +

    +

    在变异方法中给self赋值(Assigning to self Within a Mutating Method)

    变异方法能够赋给隐含属性self一个全新的实例。上面Point的例子可以用下面的方式改写：

    struct Point {
   var x = 0.0, y = 0.0
@@ -698,8 +713,8 @@ fixedPoint.moveByX(2.0, y: 3.0)
     self = Point(x: x + deltaX, y: y + deltaY)
   }
 }
-

    新版的变异方法moveByX创建了一个新的结构(它的x和y的值都被设定为目标值了)。调用这个版本的方法和调用上个版本的最终结果是一样的。

    -

    枚举的变异方法可以让self从相同的枚举设置为不同的成员：

    +

    新版的变异方法moveByX创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。

    +

    枚举的变异方法可以把self设置为相同的枚举类型中不同的成员：

    enum TriStateSwitch {
   case Off, Low, High
   mutating func next() {
@@ -715,27 +730,28 @@ fixedPoint.moveByX(2.0, y: 3.0)
 }
 var ovenLight = TriStateSwitch.Low
 ovenLight.next()
-// ovenLight is now equal to .High
+// ovenLight 现在等于 .High
 ovenLight.next()
-// ovenLight is now equal to .Off
-

    上面的例子中定义了一个三态开关的枚举。每次调用next方法时，开关在不同的电源状态(Off,Low,High)之前循环切换。

    -

    类型方法(Type Methods)

    -

    实例方法是被类型的某个实例调用的方法。你也可以定义类列本身调用的方法，这种方法就叫做类型方法。声明类的类型方法，在方法的func关键字之前加上关键字class；声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static。

    +// ovenLight 现在等于 .Off +

    上面的例子中定义了一个三态开关的枚举。每次调用next方法时，开关在不同的电源状态（Off，Low，High）之前循环切换。

    +

    +

    类型方法(Type Methods)

    +

    实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做类型方法。声明类的类型方法，在方法的func关键字之前加上关键字class；声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字static。

    注意：

    -

    在Objective-C里面，你只能为Objective-C的类定义类型方法(type-level methods)。在Swift中，你可以为所有的类、结构体和枚举定义类型方法：Each type method is explicitly scoped to the type it supports.

    +

    在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。

    -

    类型方法和实例方法一样用点语法调用。但是，你是在类型上调用这个方法，而不是在实例上调用。下面是如何在SomeClass类上调用类型方法的例子：

    +

    类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在SomeClass类上调用类型方法的例子：

    class SomeClass {
   class func someTypeMethod() {
     // type method implementation goes here
   }
 }
 SomeClass.someTypeMethod()
-

    在类型方法的方法体(body)中，self指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用self来消除静态属性和静态方法参数之间的二意性(类似于我们在前面处理实例属性和实例方法参数时做的那样)。

    -

    一般地，在类型方法里面所使用的任何未限定的方法和属性名称，将会指向其他的类型级别的方法和属性。一个类型方法可以用另一个类型方法的名称调用踏，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。

    -

    下面的例子定义了一个名为LevelTracker结构体。它监测玩家的发展情况(游戏的不同层次或阶段)。这是一个单人游戏，但也可以用作多玩家游戏中单个设备上的信息存储。

    -

    游戏初始时，所有的游戏等级(除了等级1)都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。LevelTracker结构体用静态属性和方法监测游戏的哪个等级已经被解锁。他还监测每个玩家的当前等级。

    +

    在类型方法的方法体（body）中，self指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用self来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。

    +

    一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。

    +

    下面的例子定义了一个名为LevelTracker结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。

    +

    游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。LevelTracker结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。

    struct LevelTracker {
   static var highestUnlockedLevel = 1
   static func unlockLevel(level: Int) {
@@ -755,9 +771,9 @@ SomeClass.someTypeMethod()
   }
 }

    LevelTracker监测玩家的已解锁的最高等级。这个值被存储在静态属性highestUnlockedLevel中。

    -

    LevelTracker还定义了两个类型方法与highestUnlockedLevel配合工作。第一个类型方法是unlockLevel：一旦新等级被解锁，它会更新highestUnlockedLevel的值。第二个类型方法是levelIsUnlocked：如果某个给定的等级已经被解锁，他返回true。(注意：我们没用使用LevelTracker.highestUnlockedLevel，这个类型方法还是能够访问静态属性highestUnlockedLevel)

    -

    除了静态属性和类型方法，LevelTracker还监测每个玩家的进度。它用实例属性currentLevel来监测玩家当前正在进行的等级。

    -

    为了便于管理currentLevel属性，LevelTracker定义了实例方法advanceToLevel。这个方法会在更新currentLevel之前检查所请求的新等级是否已经解锁。advanceToLevel方法返回布尔值以指示是否确实能够设置currentLevel了。

    +

    LevelTracker还定义了两个类型方法与highestUnlockedLevel配合工作。第一个类型方法是unlockLevel：一旦新等级被解锁，它会更新highestUnlockedLevel的值。第二个类型方法是levelIsUnlocked：如果某个给定的等级已经被解锁，它将返回true。（注意：尽管我们没有使用类似LevelTracker.highestUnlockedLevel的写法，这个类型方法还是能够访问静态属性highestUnlockedLevel）

    +

    除了静态属性和类型方法，LevelTracker还监测每个玩家的进度。它用实例属性currentLevel来监测玩家当前的等级。

    +

    为了便于管理currentLevel属性，LevelTracker定义了实例方法advanceToLevel。这个方法会在更新currentLevel之前检查所请求的新等级是否已经解锁。advanceToLevel方法返回布尔值以指示是否能够设置currentLevel。

    下面，Player类使用LevelTracker来监测和更新每个玩家的发展进度：

    class Player {
   var tracker = LevelTracker()
@@ -770,20 +786,21 @@ SomeClass.someTypeMethod()
     playerName = name
   }
 }
-

    Player类创建一个新的LevelTracker实例来检测这个用户的发展进度。他提供了completedLevel方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了advanceToLevel返回的布尔值，因为之前调用LevelTracker.unlockLevel时就知道了这个等级已经被解锁了）

    +

    Player类创建一个新的LevelTracker实例来监测这个用户的发展进度。他提供了completedLevel方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了advanceToLevel返回的布尔值，因为之前调用LevelTracker.unlockLevel时就知道了这个等级已经被解锁了）。

    你还可以为一个新的玩家创建一个Player的实例，然后看这个玩家完成等级一时发生了什么：

    var player = Player(name: "Argyrios")
 player.completedLevel(1)
 println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
-// prints "highest unlocked level is now 2"
-

    如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，当你试图去设置玩家当前等级时会失败的：

    +// 输出 "highest unlocked level is now 2"（最高等级现在是2 +） +

    如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：

    player = Player(name: "Beto")
 if player.tracker.advanceToLevel(6) {
 println("player is now on level 6")
 } else {
 println("level 6 has not yet been unlocked")
 }
-// prints "level 6 has not yet been unlocked"
+// 输出 "level 6 has not yet been unlocked"（等级6还没被解锁）
    @@ -829,6 +846,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/12_Subscripts.html b/chapter2/12_Subscripts.html index 2ee1dfc4..263ee9b3 100644 --- a/chapter2/12_Subscripts.html +++ b/chapter2/12_Subscripts.html @@ -5,12 +5,12 @@ - 附属脚本 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,17 +587,28 @@
    -
    +
    -

    下标（Subscripts）

    -
    -

    下标可以定义在类(Class)、结构体(structures)和枚举(enumerations)这些目标中，可以认为是访问对象、集合或序列的快捷方式。举例来说，用下标访问一个数组(Array)实例中的元素可以这样写 someArray[index] ，访问字典(Dictionary)实例中的元素可以这样写 someDictionary[key]，而不需要再调用实例的某个方法来获得元素的值。

    -

    对于同一个目标可以定义多个下标，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。

    -
    -

    译者：这里下标重载在本小节中原文并没有任何演示

    +
    +

    翻译：siemenliu

    +

    校对：zq54zquan

    -

    下标语法

    -

    下标允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和实例属性的混合。与定义实例方法类似，定义下标使用subscript关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标可以设定为读写或只读。这种方式又有点像实例属性的getter和setter：

    +

    附属脚本（Subscripts）

    +
    +

    本页包含内容：

    + +

    附属脚本 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。举例来说，用附属脚本访问一个数组(Array)实例中的元素可以这样写 someArray[index] ，访问字典(Dictionary)实例中的元素可以这样写 someDictionary[key]。

    +

    对于同一个目标可以定义多个附属脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。

    +
    +

    译者：这里附属脚本重载在本小节中原文并没有任何演示

    +
    +

    +

    附属脚本语法

    +

    附属脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义附属脚本使用subscript关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是附属脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter：

    subscript(index: Int) -> Int {
     get {
         // 返回与入参匹配的Int类型的值
@@ -607,12 +618,12 @@
         // 执行赋值操作
     }
 }
-

    newValue的类型必须和下标定义的返回类型相同。与实例属性相同的是set的入参声明newValue就算不写，在set代码块中依然可以使用newValue这个变量来访问新赋的值。

    -

    与只读实例属性一样，可以直接将原本应该写在get代码块中的代码写在subscript中即可：

    +

    newValue的类型必须和附属脚本定义的返回类型相同。与计算型属性相同的是set的入参声明newValue就算不写，在set代码块中依然可以使用默认的newValue这个变量来访问新赋的值。

    +

    与只读计算型属性一样，可以直接将原本应该写在get代码块中的代码写在subscript中：

    subscript(index: Int) -> Int {
     // 返回与入参匹配的Int类型的值
 }
-

    下面代码演示了一个在TimesTable结构体中使用只读下标的用法，该结构体用来展示传入整数的N倍。

    +

    下面代码演示了一个在TimesTable结构体中使用只读附属脚本的用法，该结构体用来展示传入整数的n倍。

    struct TimesTable {
     let multiplier: Int
     subscript(index: Int) -> Int {
@@ -622,27 +633,29 @@
 let threeTimesTable = TimesTable(multiplier: 3)
 println("3的6倍是\(threeTimesTable[6])")
 // 输出 "3的6倍是18"
-

    在上例中，通过TimesTable结构体创建了一个用来表示索引值三倍的实例。数值3作为结构体构造函数入参表示这个值将成为实例成员multiplier的值。

    -

    你可以通过下标来来得到结果，比如threeTimesTable[6]。这句话访问了threeTimesTable的第六个元素，返回18或者6的3倍。

    +

    在上例中，通过TimesTable结构体创建了一个用来表示索引值三倍的实例。数值3作为结构体构造函数入参初始化实例成员multiplier。

    +

    你可以通过附属脚本来来得到结果，比如threeTimesTable[6]。这句话访问了threeTimesTable的第六个元素，返回18或者6的3倍。

    -

    提示

    -

    TimesTable例子是基于一个固定的数学公式。它并不适合开放写权限来对threeTimesTable[someIndex]进行赋值操作，这也是为什么下标只定义为只读的原因。

    +

    注意：

    +

    TimesTable例子是基于一个固定的数学公式。它并不适合开放写权限来对threeTimesTable[someIndex]进行赋值操作，这也是为什么附属脚本只定义为只读的原因。

    -

    下标用法

    -

    下标根据使用场景不同也具有不同的含义。通常下标是用来访问集合(collection)，列表(list)或序列(sequence)中元素的快捷方式。你可以为特定的类或结构体中自由的实现下标来提供合适的功能。

    -

    例如，Swift的字典(Dictionary)实现了通过下标来对其实例中存放的值进行存取操作。在字典中设值可以通过给字典提供一个符合字典索引类型的索引值的表达式赋一个与字典存放值类型匹配的值来做到：

    +

    +

    附属脚本用法

    +

    根据使用场景不同附属脚本也具有不同的含义。通常附属脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现附属脚本来提供合适的功能。

    +

    例如，Swift 的字典（Dictionary）实现了通过附属脚本来对其实例中存放的值进行存取操作。在附属脚本中使用和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个附属脚本来为字典设值：

    var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
 numberOfLegs["bird"] = 2
-

    上例定义一个名为numberOfLegs的变量并用一个字典表达式初始化出了包含三对键值的字典实例。numberOfLegs的字典存放值类型推断为Dictionary<String, Int>。字典实例创建完成之后通过下标的方式将整型值2赋值到字典实例的索引为bird的位置中。

    -

    更多关于字典(Dictionary)下标的信息请参考字典的访问与修改

    +

    上例定义一个名为numberOfLegs的变量并用一个字典字面量初始化出了包含三对键值的字典实例。numberOfLegs的字典存放值类型推断为Dictionary<String, Int>。字典实例创建完成之后通过附属脚本的方式将整型值2赋值到字典实例的索引为bird的位置中。

    +

    更多关于字典（Dictionary）附属脚本的信息请参考读取和修改字典

    -

    提示

    -

    Swift中Dictionary的下标实现中，在get部分返回值是Int?，也就是说不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是nil；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为nil即可。

    +

    注意：

    +

    Swift 中字典的附属脚本实现中，在get部分返回值是Int?，上例中的numberOfLegs字典通过下边返回的是一个Int?或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是nil；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为nil即可。

    -

    下标选项

    -

    下标允许任意数量的入参索引，并且每个入参类型也没有限制。下标的返回值也可以是任何类型。下标可以使用变量参数和可变参数，但使用in-out参数或给参数设置默认值都是不允许的。

    -

    一个类或结构体可以根据自身需要提供多个下标实现，在定义下标时通过入参个类型进行区分，使用下标时会自动匹配合适的下标实现运行，这就是下标的重载。

    -

    一个下标入参是最常见的情况，但只要有合适的场景也可以定义多个下标入参。如下例定义了一个Matrix结构体，将呈现一个Double类型的二维数组。Matrix结构体的下标需要两个整型参数：

    +

    +

    附属脚本选项

    +

    附属脚本允许任意数量的入参索引，并且每个入参类型也没有限制。附属脚本的返回值也可以是任何类型。附属脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。

    +

    一个类或结构体可以根据自身需要提供多个附属脚本实现，在定义附属脚本时通过入参个类型进行区分，使用附属脚本时会自动匹配合适的附属脚本实现运行，这就是附属脚本的重载。

    +

    一个附属脚本入参是最常见的情况，但只要有合适的场景也可以定义多个附属脚本入参。如下例定义了一个Matrix结构体，将呈现一个Double类型的二维矩阵。Matrix结构体的附属脚本需要两个整型参数：

    struct Matrix {
     let rows: Int, columns: Int
     var grid: Double[]
@@ -665,33 +678,30 @@ numberOfLegs["bird"] = 2
         }
     }
 }
-

    Matrix提供了一个两个入参的构造方法，入参分别是rows和columns，创建了一个足够容纳rows * columns个数的Double类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考Creating and Initializing an Array。

    -

    你可以通过传入合适的row和column的数量来构造一个新的Matrix实例：

    +

    Matrix提供了一个两个入参的构造方法，入参分别是rows和columns，创建了一个足够容纳rows * columns个数的Double类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考创建并且构造一个数组。

    +

    你可以通过传入合适的row和column的数量来构造一个新的Matrix实例：

    var matrix = Matrix(rows: 2, columns: 2)
-

    上例中创建了一个新的两行两列的Matrix实例。在阅读顺序从左上到右下的Matrix实例中的数组实例grid是矩阵二维数组的扁平化存储：

    +

    上例中创建了一个新的两行两列的Matrix实例。在阅读顺序从左上到右下的Matrix实例中的数组实例grid是矩阵二维数组的扁平化存储：

    // 示意图
 grid = [0.0, 0.0, 0.0, 0.0]
 
         col0     col1
 row0   [0.0,     0.0,
 row1    0.0,     0.0]
-

    将值赋给带有row和column下标的matrix实例表达式可以完成赋值操作，下标入参使用逗号分割

    +

    将值赋给带有row和column附属脚本的matrix实例表达式可以完成赋值操作，附属脚本入参使用逗号分割

    matrix[0, 1] = 1.5
 matrix[1, 0] = 3.2
-

    上面两句话分别让matrix的右上值为1.5，坐下值为3.2：

    +

    上面两条语句分别让matrix的右上值为 1.5，坐下值为 3.2：

    [0.0, 1.5,
  3.2, 0.0]
-

    Matrix下标的getter和setter中同时调用了下标入参的row和column是否有效的判断。为了方便进行断言，Matrix包含了一个名为indexIsValid的成员方法，用来确认入参的row或column值是否会造成数组越界：

    +

    Matrix附属脚本的getter和setter中同时调用了附属脚本入参的row和column是否有效的判断。为了方便进行断言，Matrix包含了一个名为indexIsValid的成员方法，用来确认入参的row或column值是否会造成数组越界：

    func indexIsValidForRow(row: Int, column: Int) -> Bool {
     return row >= 0 && row < rows && column >= 0 && column < columns
 }
-

    断言在下标越界时触发：

    +

    断言在附属脚本越界时触发：

    let someValue = matrix[2, 2]
 // 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度
-
    -

    译者：这里有个词Computed Properties 这里统一翻译为实例属性了 微软术语引擎里没有这个词

    -
    - +
    @@ -736,6 +746,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/13_Inheritance.html b/chapter2/13_Inheritance.html index 4874adf8..a52b210f 100644 --- a/chapter2/13_Inheritance.html +++ b/chapter2/13_Inheritance.html @@ -5,12 +5,12 @@ - 继承 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,17 +587,30 @@
    -
    +
    -

    继承

    +
    +

    翻译：Hawstein

    +

    校对：menlongsheng

    +
    +

    继承（Inheritance）

    -

    一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类，继承类叫子类，被继承类叫超类（或父类）。在Swift中，继承是区分「类」与其它类型的一个基本特征。

    -

    在Swift中，类可以调用和访问超类的方法，属性和下标，并且可以重写（override）这些方法，属性和下标来优化或修改它们的行为。Swift会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。

    +

    本页包含内容：

    + +

    一个类可以继承（inherit）另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫子类（subclass），被继承类叫超类（或父类，superclass）。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。

    +

    在 Swift 中，类可以调用和访问超类的方法，属性和附属脚本（subscripts），并且可以重写（override）这些方法，属性和附属脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。

    可以为类中继承来的属性添加属性观察器（property observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。

    -

    定义一个基类

    -

    不继承于其它类的类，称之为基类。

    +

    +

    定义一个基类（Base class）

    +

    不继承于其它类的类，称之为基类（base calss）。

    -

    注意：Swift中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。

    +

    注意：

    +

    Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。

    下面的例子定义了一个叫Vehicle的基类。这个基类声明了两个对所有车辆都通用的属性（numberOfWheels和maxPassengers）。这些属性在description方法中使用，这个方法返回一个String类型的，对车辆特征的描述：

    class Vehicle {
@@ -611,23 +624,24 @@
         maxPassengers = 1
     }
 }
-

    Vehicle类定义了初始化器（initializer）来设置属性的值。初始化器会在构造函数一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性可以如何被修改。

    -

    初始化器用于创建某个类型的一个新实例。尽管初始化器并不是方法，但在语法上，两者很相似。初始化器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。

    -

    初始化器的最简单形式就像一个没有参数的实例方法，使用init关键字：

    +

    Vehicle类定义了构造器（initializer）来设置属性的值。构造器会在构造过程一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性如何被修改。

    +

    构造器用于创建某个类型的一个新实例。尽管构造器并不是方法，但在语法上，两者很相似。构造器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。

    +

    构造器的最简单形式就像一个没有参数的实例方法，使用init关键字：

    init() {
-    // perform some initialization here
+    // 执行构造过程
 }
-

    如果要创建一个Vehicle类的新实例，使用初始化器语法调用上面的初始化器，即类名后面跟一个空的小括号：

    +

    如果要创建一个Vehicle类的新实例，使用构造器语法调用上面的初始化器，即类名后面跟一个空的小括号：

    let someVehicle = Vehicle()
-

    这个Vehicle类的初始化器为任意的一辆车设置一些初始化属性值（numberOfWheels = 0和maxPassengers = 1）。

    +

    这个Vehicle类的构造器为任意的一辆车设置一些初始化属性值（numberOfWheels = 0和maxPassengers = 1）。

    Vehicle类定义了车辆的共同特性，但这个类本身并没太大用处。为了使它更为实用，你需要进一步细化它来描述更具体的车辆。

    -

    Subclassing（子类化？待定）

    -

    subclassing指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且你可以优化或改变它。你还可以为子类添加新的特性。

    +

    +

    子类生成（Subclassing）

    +

    子类生成（Subclassing）指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以优化或改变它。你还可以为子类添加新的特性。

    为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔：

    class SomeClass: SomeSuperclass {
-    // class definition goes here
+    // 类的定义
 }
-

    下一个例子，定义一个更具体的车辆类叫Bicycle。这个新类是在Vehicle类的基础上创建起来。因此你需要将Vehicle类放在Bicycle类后面，用冒号分隔。

    +

    下一个例子，定义一个更具体的车辆类叫Bicycle。这个新类是在 Vehicle类的基础上创建起来。因此你需要将Vehicle类放在 Bicycle类后面，用冒号分隔。

    我们可以将这读作：

    “定义一个新的类叫Bicycle，它继承了Vehicle的特性”；

    class Bicycle: Vehicle {
@@ -636,12 +650,13 @@
         numberOfWheels = 2
     }
 }
-

    Bicycle是Vehicle的子类，Vehicle是Bicycle的超类。新的Bicycle类自动获得Vehicle类的特性，比如maxPassengers和numberOfWheels属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述Bicycle类。

    -

    Bicycle类定义了一个初始化器来设置它定制的特性（自行车只有2个轮子）。Bicycle的初始化器调用了它父类Vehicle的初始化器super.init()，以此确保在Bicycle类试图修改那些继承来的属性前，Vehicle类已经初始化过它们了。

    +

    Bicycle是Vehicle的子类，Vehicle是Bicycle的超类。新的Bicycle类自动获得Vehicle类的特性，比如 maxPassengers和numberOfWheels属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述Bicycle类。

    +

    Bicycle类定义了一个构造器来设置它定制的特性（自行车只有2个轮子）。Bicycle的构造器调用了它父类Vehicle的构造器 super.init()，以此确保在Bicycle类试图修改那些继承来的属性前Vehicle类已经初始化过它们了。

    -

    注意：不像Objective-C，在Swift中，初始化器默认是不继承的，见初始化器的继承与重写

    +

    注意：

    +

    不像 Objective-C，在 Swift 中，初始化器默认是不继承的，见初始化器的继承与重写

    -

    Vehicle类中maxPassengers的默认值对自行车来说已经是正确的，因此在Bicycle的初始化器中并没有改变它。而numberOfWheels原来的值对自行车来说是不正确的，因此在初始化器中将它更改为2。

    +

    Vehicle类中maxPassengers的默认值对自行车来说已经是正确的，因此在Bicycle的构造器中并没有改变它。而numberOfWheels原来的值对自行车来说是不正确的，因此在初始化器中将它更改为 2。

    Bicycle不仅可以继承Vehicle的属性，还可以继承它的方法。如果你创建了一个Bicycle类的实例，你就可以调用它继承来的description方法，并且可以看到，它输出的属性值已经发生了变化：

    let bicycle = Bicycle()
 println("Bicycle: \(bicycle.description())")
@@ -653,30 +668,32 @@ println("Bicycle: \(bicycle.description())")
         maxPassengers = 2
     }
 }
-

    上面的例子创建了Bicycle的一个子类：双人自行车（tandem）。Tandem从Bicycle继承了两个属性，而这两个属性是Bicycle从Vehicle继承而来的。Tandem并不修改轮子的数量，因为它仍是一辆自行车，有2个轮子。但它需要修改maxPassengers的值，因为双人自行车可以坐两个人。

    +

    上面的例子创建了Bicycle的一个子类：双人自行车（tandem）。Tandem从Bicycle继承了两个属性，而这两个属性是Bicycle从Vehicle继承而来的。Tandem并不修改轮子的数量，因为它仍是一辆自行车，有 2 个轮子。但它需要修改maxPassengers的值，因为双人自行车可以坐两个人。

    -

    注意：子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。

    +

    注意：

    +

    子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。

    创建一个Tandem类的实例，打印它的描述，即可看到它的属性已被更新：

    let tandem = Tandem()
 println("Tandem: \(tandem.description())")
 // Tandem: 2 wheels; up to 2 passengers

    注意，Tandem类也继承了description方法。一个类的实例方法会被这个类的所有子类继承。

    +

    重写（Overriding）

    -

    子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overriding）。

    +

    子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或附属脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overriding）。

    如果要重写某个特性，你需要在重写定义的前面加上override关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少override关键字的重写都会在编译时被诊断为错误。

    -

    override关键字会提醒Swift编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。

    -

    访问超类的方法，属性及下标

    -

    当你在子类中重写超类的方法，属性或下标时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。

    -

    在合适的地方，你可以通过使用super前缀来访问超类版本的方法，属性或下标：

    +

    override关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。

    +

    访问超类的方法，属性及附属脚本

    +

    当你在子类中重写超类的方法，属性或附属脚本时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。

    +

    在合适的地方，你可以通过使用super前缀来访问超类版本的方法，属性或附属脚本：

    • 在方法someMethod的重写实现中，可以通过super.someMethod()来调用超类版本的someMethod方法。
      • -
    • 在属性someProperty的getter或setter的重写实现中，可以通过super.someProperty来访问超类版本的someProperty属性。
      • -
    • 在下标的重写实现中，可以通过super[someIndex]来访问超类版本中的相同下标。
      • +
    • 在属性someProperty的 getter 或 setter 的重写实现中，可以通过super.someProperty来访问超类版本的someProperty属性。
      • +
    • 在附属脚本的重写实现中，可以通过super[someIndex]来访问超类版本中的相同附属脚本。

    重写方法

    在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。

    -

    下面的例子定义了Vehicle的一个新的子类，叫Car，它重写了从Vehicle类继承来的'description'方法：

    +

    下面的例子定义了Vehicle的一个新的子类，叫Car，它重写了从Vehicle类继承来的description方法：

    class Car: Vehicle {
     var speed: Double = 0.0
     init() {
@@ -689,7 +706,7 @@ println("Tandem: \(tandem.description())")
             + "traveling at \(speed) mph"
     }
 }
-

    Car声明了一个新的存储型属性speed，它是Double类型的，默认值是0.0，表示“时速是0英里”。'Car'有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。

    +

    Car声明了一个新的存储型属性speed，它是Double类型的，默认值是0.0，表示“时速是0英里”。Car有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。

    Car重写了继承来的description方法，它的声明与Vehicle中的description方法一致，声明前面加上了override关键字。

    Car中的description方法并非完全自定义，而是通过super.description使用了超类Vehicle中的description方法，然后再追加一些额外的信息，比如汽车的当前速度。

    如果你创建一个Car的新实例，并打印description方法的输出，你就会发现描述信息已经发生了改变：

    @@ -699,10 +716,11 @@ println("Car: \(car.description())")

    重写属性

    你可以重写继承来的实例属性或类属性，提供自己定制的getter和setter，或添加属性观察器使重写的属性观察属性值什么时候发生改变。

    重写属性的Getters和Setters

    -

    你可以提供定制的getter（或setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。

    -

    你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供getter和setter即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。

    +

    你可以提供定制的 getter（或 setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。

    +

    你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。

    -

    注意：如果你在重写属性中提供了setter，那么你也一定要提供getter。如果你不想在重写版本中的getter里修改继承来的属性值，你可以直接返回super.someProperty来返回继承来的值。正如下面的SpeedLimitedCar的例子所示。

    +

    注意：

    +

    如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改继承来的属性值，你可以直接返回super.someProperty来返回继承来的值。正如下面的SpeedLimitedCar的例子所示。

    以下的例子定义了一个新类，叫SpeedLimitedCar，它是Car的子类。类SpeedLimitedCar表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的speed属性来实现这个速度限制：

    class SpeedLimitedCar: Car {
@@ -722,9 +740,10 @@ limitedCar.speed = 60.0
 println("SpeedLimitedCar: \(limitedCar.description())")
 // SpeedLimitedCar: 4 wheels; up to 5 passengers; traveling at 40.0 mph

    重写属性观察器（Property Observer）

    -

    你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看属性观察器。

    +

    你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看属性观察器。

    -

    注意：你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供willSet或didSet实现是不恰当。此外还要注意，你不可以同时提供重写的setter和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的setter，那么你在setter中就可以观察到任何值变化了。

    +

    注意：

    +

    你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供willSet或didSet实现是不恰当。此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。

    下面的例子定义了一个新类叫AutomaticCar，它是Car的子类。AutomaticCar表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。AutomaticCar也提供了定制的description方法，可以输出当前挡位。

    class AutomaticCar: Car {
@@ -738,15 +757,16 @@ println("SpeedLimitedCar: \(limitedCar.description())")
         return super.description() + " in gear \(gear)"
     }
 }
-

    当你设置AutomaticCar的speed属性，属性的didSet观察器就会自动地设置gear属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位gear的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：

    +

    当你设置AutomaticCar的speed属性，属性的didSet观察器就会自动地设置gear属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位gear的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：

    let automatic = AutomaticCar()
 automatic.speed = 35.0
 println("AutomaticCar: \(automatic.description())")
 // AutomaticCar: 4 wheels; up to 5 passengers; traveling at 35.0 mph in gear 4
-

    防止重写

    -

    你可以通过把方法，属性或下标标记为final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@final var, @final func, @final class func, 以及 @final subscript）

    -

    如果你重写了final方法，属性或下标，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标也可以在扩展的定义里标记为final。

    -

    你可以通过在关键字class前添加@final特性（@final class）来将整个类标记为final的，这样的类是不可被继承的，否则会报编译错误。

    +

    +

    防止重写

    +

    你可以通过把方法，属性或附属脚本标记为final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@final var, @final func, @final class func, 以及 @final subscript）

    +

    如果你重写了final方法，属性或附属脚本，在编译时会报错。在扩展中，你添加到类里的方法，属性或附属脚本也可以在扩展的定义里标记为 final。

    +

    你可以通过在关键字class前添加@final特性（@final class）来将整个类标记为 final 的，这样的类是不可被继承的，否则会报编译错误。

    @@ -792,6 +812,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/14_Initialization.html b/chapter2/14_Initialization.html index a5de30f4..d1b6904e 100644 --- a/chapter2/14_Initialization.html +++ b/chapter2/14_Initialization.html @@ -5,12 +5,12 @@ - 构造过程 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,6 +587,439 @@
    +
    + +
    +

    翻译：lifedim

    +

    校对：lifedim

    +
    +

    构造过程（Initialization）

    +
    +

    本页包含内容：

    + +

    构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务。

    +

    构造过程是通过定义构造器（Initializers）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。

    +

    类实例也可以通过定义析构器（deinitializer）在类实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考析构过程。

    +

    +

    存储型属性的初始赋值

    +

    类和结构体在实例创建时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。

    +

    你可以在构造器中为存储型属性赋初值，也可以在定义属性时为其设置默认值。以下章节将详细介绍这两种方法。

    +
    +

    注意：

    +

    当你为存储型属性设置默认值或者在构造器中为其赋值时，它们的值是被直接设置的，不会触发任何属性观测器（property observers）。

    +
    +

    构造器

    +

    构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字init命名。

    +

    下面例子中定义了一个用来保存华氏温度的结构体Fahrenheit，它拥有一个Double类型的存储型属性temperature：

    +
    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设置默认值：

    +
    struct Fahrenheit {
+    var temperature = 32.0
+}
+

    +

    定制化构造过程

    +

    你可以通过输入参数和可选属性类型来定制构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。

    +

    构造参数

    +

    你可以在定义构造器时提供构造参数，为其提供定制化构造所需值的类型和名字。构造器参数的功能和语法跟函数和方法参数相同。

    +

    下面例子中定义了一个包含摄氏度温度的结构体Celsius。它定义了两个不同的构造器：init(fromFahrenheit:)和init(fromKelvin:)，二者分别通过接受不同刻度表示的温度值来创建新的实例：

    +
    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类型的构造参数：

    +
    struct Color {
+    let red = 0.0, green = 0.0, blue = 0.0
+    init(red: Double, green: Double, blue: Double) {
+        self.red   = red
+        self.green = green
+        self.blue  = blue
+    }
+}
+

    每当你创建一个新的Color实例，你都需要通过三种颜色的外部参数名来传值，并调用构造器。

    +
    let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
+

    注意，如果不通过外部参数名字传值，你是没法调用这个构造器的。只要构造器定义了某个外部参数名，你就必须使用它，忽略它将导致编译错误：

    +
    let veryGreen = Color(0.0, 1.0, 0.0)
+// 报编译时错误，需要外部名称
+

    可选属性类型

    +

    如果你定制的类型包含一个逻辑上允许取值为空的存储型属性--不管是因为它无法在初始化时赋值，还是因为它可以在之后某个时间点可以赋值为空--你都需要将它定义为可选类型optional type。可选类型的属性将自动初始化为空nil，表示这个属性是故意在初始化时设置为空的。

    +

    下面例子中定义了类SurveyQuestion，它包含一个可选字符串属性response：

    +
    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属性现在是常量，我们仍然可以在其类的构造器中修改它的值：

    +
    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.)
+

    +

    默认构造器

    +

    Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类，提供一个默认的构造器。这个默认构造器将简单的创建一个所有属性值都设置为默认值的实例。

    +

    下面例子中创建了一个类ShoppingListItem，它封装了购物清单中的某一项的属性：名字（name）、数量（quantity）和购买状态 purchase state。

    +
    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创建新的实例：

    +
    struct Size {
+    var width = 0.0, height = 0.0
+}
+let twoByTwo = Size(width: 2.0, height: 2.0)
+

    +

    值类型的构造器代理

    +

    构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。

    +

    构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理任务给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考继承），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节类的继承和构造过程中介绍。

    +

    对于值类型，你可以使用self.init在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用self.init。

    +

    注意，如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。

    +
    +

    注意：

    +

    假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（extension）中，而不是跟值类型定义混在一起。想查看更多内容，请查看扩展章节。

    +
    +

    下面例子将定义一个结构体Rect，用来展现几何矩形。这个例子需要两个辅助的结构体Size和Point，它们各自为其所有的属性提供了初始值0.0。

    +
    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结构体定义中，我们为着三种方式提供了三个自定义的构造器：

    +
    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)：

    +
    let basicRect = Rect()
+// basicRect 的原点是 (0.0, 0.0)，尺寸是 (0.0, 0.0)
+

    第二个Rect构造器init(origin:size:)，在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的。这个构造器只是简单的将origin和size的参数值赋给对应的存储型属性：

    +
    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值赋值到对应的属性中：

    +

    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:)的方式来实现这个例子，请参考扩展。

    +
    +

    +

    类的继承和构造过程

    +

    类里面的所有存储型属性--包括所有继承自父类的属性--都必须在构造过程中设置初始值。

    +

    Swift 提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。

    +

    指定构造器和便利构造器

    +

    指定构造器是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。

    +

    每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节自动构造器的继承。

    +

    便利构造器是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。

    +

    你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清、晰明。

    +

    +

    构造器链

    +

    为了简化指定构造器和便利构造器之间的调用关系，Swift 采用以下三条规则来限制构造器之间的代理调用：

    +

    规则 1

    +

    指定构造器必须调用其直接父类的的指定构造器。

    +

    规则 2

    +

    便利构造器必须调用同一类中定义的其它构造器。

    +

    规则 3

    +

    便利构造器必须最终以调用一个指定构造器结束。

    +

    一个更方便记忆的方法是：

    +
      +
    • 指定构造器必须总是向上代理
      • +
    • 便利构造器必须总是横向代理
      • +
    +

    这些规则可以通过下面图例来说明：

    +

    构造器代理图

    +

    如图所示，父类中包含一个指定构造器和两个便利构造器。其中一个便利构造器调用了另外一个便利构造器，而后者又调用了唯一的指定构造器。这满足了上面提到的规则2和3。这个父类没有自己的父类，所以规则1没有用到。

    +

    子类中包含两个指定构造器和一个便利构造器。便利构造器必须调用两个指定构造器中的任意一个，因为它只能调用同一个类里的其他构造器。这满足了上面提到的规则2和3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则1。

    +
    +

    注意：

    +

    这些规则不会影响使用时，如何用类去创建实例。任何上图中展示的构造器都可以用来完整创建对应类的实例。这些规则只在实现类的定义时有影响。

    +
    +

    下面图例中展示了一种更复杂的类层级结构。它演示了指定构造器是如果在类层级中充当“管道”的作用，在类的构造器链上简化了类之间的内部关系。

    +

    复杂构造器代理图

    +

    +

    两段式构造过程

    +

    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

    +

    在这个例子中，构造过程从对子类中一个便利构造器的调用开始。这个便利构造器此时没法修改任何属性，它把构造任务代理给同一类中的指定构造器。

    +

    如安全检查1所示，指定构造器将确保所有子类的属性都有值。然后它将调用父类的指定构造器，并沿着造器链一直往上完成父类的构建过程。

    +

    父类中的指定构造器确保所有父类的属性都有值。由于没有更多的父类需要构建，也就无需继续向上做构建代理。

    +

    一旦父类中所有属性都有了初始值，实例的内存被认为是完全初始化，而阶段1也已完成。

    +

    以下展示了相同构造过程的阶段2：

    +

    构建过程阶段2

    +

    父类中的指定构造器现在有机会进一步来定制实例（尽管它没有这种必要）。

    +

    一旦父类中的指定构造器完成调用，子类的构指定构造器可以执行更多的定制操作（同样，它也没有这种必要）。

    +

    最终，一旦子类的指定构造器完成调用，最开始被调用的便利构造器可以执行更多的定制操作。

    +

    构造器的继承和重载

    +

    跟 Objective-C 中的子类不同，Swift 中的子类不会默认继承父类的构造器。Swift 的这种机制可以防止一个父类的简单构造器被一个更专业的子类继承，并被错误的用来创建子类的实例。

    +

    假如你希望自定义的子类中能实现一个或多个跟父类相同的构造器--也许是为了完成一些定制的构造过程--你可以在你定制的子类中提供和重载与父类相同的构造器。

    +

    如果你重载的构造器是一个指定构造器，你可以在子类里重载它的实现，并在自定义版本的构造器中调用父类版本的构造器。

    +

    如果你重载的构造器是一个便利构造器，你的重载过程必须通过调用同一类中提供的其它指定构造器来实现。这一规则的详细内容请参考构造器链。

    +
    +

    注意：

    +

    与方法、属性和下标不同，在重载构造器时你没有必要使用关键字override。

    +
    +

    +

    自动构造器的继承

    +

    如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重载父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。

    +

    假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：

    +

    规则 1

    +

    如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。

    +

    规则 2

    +

    如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器。

    +

    即使你在子类中添加了更多的便利构造器，这两条规则仍然适用。

    +
    +

    注意：

    +

    子类可以通过部分满足规则2的方式，使用子类便利构造器来实现父类的指定构造器。

    +
    +

    指定构造器和便利构造器的语法

    +

    类的指定构造器的写法跟值类型简单构造器一样：

    +
    init(parameters) {
+    statements
+}
+

    便利构造器也采用相同样式的写法，但需要在init关键字之前放置convenience关键字，并使用空格将它们俩分开：

    +
    convenience init(parameters) {
+    statements
+}
+

    指定构造器和便利构造器实战

    +

    接下来的例子将在实战中展示指定构造器、便利构造器和自动构造器的继承。它定义了包含三个类Food、RecipeIngredient以及ShoppingListItem的类层次结构，并将演示它们的构造器是如何相互作用的。

    +

    类层次中的基类是Food，它是一个简单的用来封装食物名字的类。Food类引入了一个叫做name的String类型属性，并且提供了两个构造器来创建Food实例：

    +
    class Food {
+    var name: String
+    init(name: String) {
+        self.name = name
+    }
+    convenience init() {
+        self.init(name: "[Unnamed]")
+    }
+}
+

    下图中展示了Food的构造器链：

    +

    Food构造器链

    +

    类没有提供一个默认的逐一成员构造器，所以Food类提供了一个接受单一参数name的指定构造器。这个构造器可以使用一个特定的名字来创建新的Food实例：

    +
    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]来实现：

    +
    let mysteryMeat = Food()
+// mysteryMeat 的名字是 [Unnamed]
+

    类层级中的第二个类是Food的子类RecipeIngredient。RecipeIngredient类构建了食谱中的一味调味剂。它引入了Int类型的数量属性quantity（以及从Food继承过来的name属性），并且定义了两个构造器来创建RecipeIngredient实例：

    +
    class RecipeIngredient: Food {
+    var quantity: Int
+    init(name: String, quantity: Int) {
+        self.quantity = quantity
+        super.init(name: name)
+    }
+    convenience init(name: String) {
+        self.init(name: name, quantity: 1)
+    }
+}
+

    下图中展示了RecipeIngredient类的构造器链：

    +

    RecipeIngredient构造器

    +

    RecipeIngredient类拥有一个指定构造器init(name: String, quantity: Int)，它可以用来产生新RecipeIngredient实例的所有属性值。这个构造器一开始先将传入的quantity参数赋值给quantity属性，这个属性也是唯一在RecipeIngredient中新引入的属性。随后，构造器将任务向上代理给父类Food的init(name: String)。这个过程满足两段式构造过程中的安全检查1。

    +

    RecipeIngredient也定义了一个便利构造器init(name: String)，它只通过name来创建RecipeIngredient的实例。这个便利构造器假设任意RecipeIngredient实例的quantity为1，所以不需要显示指明数量即可创建出实例。这个便利构造器的定义可以让创建实例更加方便和快捷，并且避免了使用重复的代码来创建多个quantity为 1 的RecipeIngredient实例。这个便利构造器只是简单的将任务代理给了同一类里提供的指定构造器。

    +

    注意，RecipeIngredient的便利构造器init(name: String)使用了跟Food中指定构造器init(name: String)相同的参数。尽管RecipeIngredient这个构造器是便利构造器，RecipeIngredient依然提供了对所有父类指定构造器的实现。因此，RecipeIngredient也能自动继承了所有父类的便利构造器。

    +

    在这个例子中，RecipeIngredient的父类是Food，它有一个便利构造器init()。这个构造器因此也被RecipeIngredient继承。这个继承的init()函数版本跟Food提供的版本是一样的，除了它是将任务代理给RecipeIngredient版本的init(name: String)而不是Food提供的版本。

    +

    所有的这三种构造器都可以用来创建新的RecipeIngredient实例：

    +
    let oneMysteryItem = RecipeIngredient()
+let oneBacon = RecipeIngredient(name: "Bacon")
+let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
+

    类层级中第三个也是最后一个类是RecipeIngredient的子类，叫做ShoppingListItem。这个类构建了购物单中出现的某一种调味料。

    +

    购物单中的每一项总是从unpurchased未购买状态开始的。为了展现这一事实，ShoppingListItem引入了一个布尔类型的属性purchased，它的默认值是false。ShoppingListItem还添加了一个计算型属性description，它提供了关于ShoppingListItem实例的一些文字描述：

    +
    class ShoppingListItem: RecipeIngredient {
+    var purchased = false
+    var description: String {
+    var output = "\(quantity) x \(name.lowercaseString)"
+        output += purchased ? " ✔" : " ✘"
+        return output
+    }
+}
+
    +

    注意：

    +

    ShoppingListItem没有定义构造器来为purchased提供初始化值，这是因为任何添加到购物单的项的初始状态总是未购买。

    +
    +

    由于它为自己引入的所有属性都提供了默认值，并且自己没有定义任何构造器，ShoppingListItem将自动继承所有父类中的指定构造器和便利构造器。

    +

    下图种展示了所有三个类的构造器链：

    +

    三类构造器图

    +

    你可以使用全部三个继承来的构造器来创建ShoppingListItem的新实例：

    +
    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，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。

    +

    +

    通过闭包和函数来设置属性的默认值

    +

    如果某个存储型属性的默认值需要特别的定制或准备，你就可以使用闭包或全局函数来为其属性提供定制的默认值。每当某个属性所属的新类型实例创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。

    +

    这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。

    +

    下面列举了闭包如何提供默认值的代码概要：

    +
    class SomeClass {
+    let someProperty: SomeType = {
+        // 在这个闭包中给 someProperty 创建一个默认值
+        // someValue 必须和 SomeType 类型相同
+        return someValue
+        }()
+}
+

    注意闭包结尾的大括号后面接了一对空的小括号。这是用来告诉 Swift 需要立刻执行此闭包。如果你忽略了这对括号，相当于是将闭包本身作为值赋值给了属性，而不是将闭包的返回值赋值给属性。

    +
    +

    注意：

    +

    如果你使用闭包来初始化属性的值，请记住在闭包执行时，实例的其它部分都还没有初始化。这意味着你不能够在闭包里访问其它的属性，就算这个属性有默认值也不允许。同样，你也不能使用隐式的self属性，或者调用其它的实例方法。

    +
    +

    下面例子中定义了一个结构体Checkerboard，它构建了西洋跳棋游戏的棋盘：

    +

    西洋跳棋棋盘

    +

    西洋跳棋游戏在一副黑白格交替的 10x10 的棋盘中进行。为了呈现这副游戏棋盘，Checkerboard结构体定义了一个属性boardColors，它是一个包含 100 个布尔值的数组。数组中的某元素布尔值为true表示对应的是一个黑格，布尔值为false表示对应的是一个白格。数组中第一个元素代表棋盘上左上角的格子，最后一个元素代表棋盘上右下角的格子。

    +

    boardColor数组是通过一个闭包来初始化和组装颜色值的：

    +
    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这个工具函数来查询。

    +
    let board = Checkerboard()
+println(board.squareIsBlackAtRow(0, column: 1))
+// 输出 "true"
+println(board.squareIsBlackAtRow(9, column: 9))
+// 输出 "false"
+
    + +
    +
    • @@ -628,6 +1061,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/15_Deinitialization.html b/chapter2/15_Deinitialization.html index 4a9192a5..cf65fe22 100644 --- a/chapter2/15_Deinitialization.html +++ b/chapter2/15_Deinitialization.html @@ -5,12 +5,12 @@ - 析构过程 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,69 +587,80 @@
    -
    +
    -

    析构过程

    +
    +

    翻译：bruce0505

    +

    校对：fd5788

    +
    +

    析构过程（Deinitialization）

    -

    在一个类的实例被释放之前，析构函数被立即调用。用关键字deinit来标示析构函数，类似于初始化函数用init来标示。析构函数只适用于类类型。

    +

    本页包含内容：

    + +

    在一个类的实例被释放之前，析构函数被立即调用。用关键字deinit来标示析构函数，类似于初始化函数用init来标示。析构函数只适用于类类型。

    +

    析构过程原理

    -

    Swift会自动释放不再需要的实例以释放资源。如自动引用计数那一章描述，Swift通过自动引用计数（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动的去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。

    -

    在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号:

    -
    1  deinit {
-2       // 执行析构过程
-3  }
+
    Swift 会自动释放不再需要的实例以释放资源。如自动引用计数那一章描述，Swift 通过自动引用计数（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
    
+
    在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号：
    
+
    deinit {
+    // 执行析构过程
+}
 
    析构函数是在实例释放发生前一步被自动调用。不允许主动调用自己的析构函数。子类继承了父类的析构函数，并且在子类析构函数实现的最后，父类的析构函数被自动调用。即使子类没有提供自己的析构函数，父类的析构函数也总是被调用。
    
-
    因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为(比如查找一个需要被关闭的文件的名称)。
    
+
    因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件的名称）。
    
+
    
 
    析构函数操作
    
-
    这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，Bank和Player。Bank结构体管理一个虚拟货币的流通，在这个流通中Bank永远不可能拥有超过10,000的硬币。在这个游戏中有且只能有一个Bank存在，因此Bank由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
    
-
    1  struct Bank {
-2      static var coinsInBank = 10_000
-3      static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
-4         numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
-5         coinsInBank -= numberOfCoinsToVend
-6         return numberOfCoinsToVend
-7      }
-8       static func receiveCoins(coins: Int) {
-9    coinsInBank += coins
-10     }
-11  }
-
    Bank根据它的coinsInBank属性来跟踪当前它拥有的硬币数量。银行还提供两个方法—vendCoins和receiveCoins，用来处理硬币的分发和收集。
    
-
    vendCoins方法在bank分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，bank返回一个比请求时小的数字(如果没有硬币留在bank中就返回0)。vendCoins方法声明numberOfCoinsToVend为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。vendCoins方法返回一个整型值，表明了提供的硬币的实际数目。
    
-
    receiveCoins方法只是将bank的硬币存储和接收到的硬币数目相加，再保存回bank。
    
-
    Player类描述了游戏中的一个玩家。每一个player在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过player的coinsInPurse属性来体现:
    
-
        1  class Player {
-    2     var coinsInPurse: Int
-    3     init(coins: Int) {
-    4         coinsInPurse = Bank.vendCoins(coins)
-    5     }
-    6     func winCoins(coins: Int) {
-    7         coinsInPurse += Bank.vendCoins(coins)
-    8     }
-    9     deinit {
-    10        Bank.receiveCoins(coinsInPurse)
-    11    }
-    12  }
-
    每个Player实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在bank初始化的过程中得到。如果没有足够的硬币可用，Player实例可能收到比指定数目少的硬币。
    
-
    Player类定义了一个winCoins方法，该方法从bank获取一定数量的硬币，并把它们添加到player的钱包。Player类还实现了一个析构函数，这个析构函数在Player实例释放前一步被调用。这里析构函数只是将player的所有硬币都返回给bank:
    
-
    1  var playerOne: Player? = Player(coins: 100)
-2  println("A new player has joined the game with \    (playerOne!.coinsInPurse) coins")
-3  // 输出 "A new player has joined the game with 100     coins"
-4  println("There are now \(Bank.coinsInBank) coins left     in the bank")
-5  // 输出 "There are now 9900 coins left in the bank"
-
    一个新的Player实例随着一个100个硬币(如果有)的请求而被创建。这个Player实例存储在一个名为playerOne的可选Player变量中。这里使用一个可选变量，是因为players可以随时离开游戏。设置为可选使得你可以跟踪当前是否有player在游戏中。
    
-
    因为playerOne是可选的，所以由一个感叹号(!)来修饰，每当其winCoins方法被调用时，coinsInPurse属性被访问并打印出它的默认硬币数目。
    
-
    1  playerOne!.winCoins(2_000)
-2  println("PlayerOne won 2000 coins & now has \    (playerOne!.coinsInPurse) coins")
-3  // 输出 "PlayerOne won 2000 coins & now has 2100 coins"
-4  println("The bank now only has \(Bank.coinsInBank) coins left")
-5  // 输出 "The bank now only has 7900 coins left"
-
    这里，player已经赢得了2,000硬币。player的钱包现在有2,100硬币，bank只剩余7,900硬币。
    
-
    1  playerOne = nil
-2  println("PlayerOne has left the game")
-3  // 输出 "PlayerOne has left the game"
-4  println("The bank now has \(Bank.coinsInBank) coins")
-5  // 输出 "The bank now has 10000 coins"
-
    player现在已经离开了游戏。这表明是要将可选的playerOne变量设置为nil，意思是"没有Player实例"。当这种情况发生的时候，playerOne变量对Player实例的引用被破坏了。没有其它属性或者变量引用Player实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到bank。
    
+
    这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，Bank和Player。Bank结构体管理一个虚拟货币的流通，在这个流通中Bank永远不可能拥有超过 10,000 的硬币。在这个游戏中有且只能有一个Bank存在，因此Bank由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
    
+
    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属性来体现：
    
+
        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实例释放前一步被调用。这里析构函数只是将玩家的所有硬币都返回给银行：
    
+
    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属性被访问并打印出它的默认硬币数目。
    
+
    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 硬币。
    
+
    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实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到银行。
    @@ -695,6 +706,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/16_Automatic_Reference_Counting.html b/chapter2/16_Automatic_Reference_Counting.html index 4d892aa8..2c37a473 100644 --- a/chapter2/16_Automatic_Reference_Counting.html +++ b/chapter2/16_Automatic_Reference_Counting.html @@ -5,12 +5,12 @@ - 自动引用计数 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,31 +587,38 @@
    -
    +
    -

    自动引用计数

    +
    +

    翻译：TimothyYe

    +

    校对：Hawstein

    +
    +

    自动引用计数

    本页包含内容：

    -

    Swift使用自动引用计数(ARC)这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC会在类的实例不再被使用时，自动释放其占用的内存。

    -

    然而，在少数情况下，ARC为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用ARC来管理你的应用程序的内存。

    +

    Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。

    +

    然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。

    -

    注意: 引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。

    +

    注意:

    +

    引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。

    +

    自动引用计数的工作机制

    -

    当你每次创建一个类的新的实例的时候，ARC会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。

    -

    然而，当ARC收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。

    -

    为了确保使用中的实例不会被销毁，ARC会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。

    +

    当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。

    +

    然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。

    +

    为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。

    为了使之成为可能，无论你将实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。

    +

    自动引用计数实战

    -

    下面的例子展示了自动引用计数的工作机制。例子以一个简单的Person类开始，并定义了一个叫name的常量属性：

    +

    下面的例子展示了自动引用计数的工作机制。例子以一个简单的Person类开始，并定义了一个叫name的常量属性：

        class Person {
         let name: String
 
@@ -624,31 +631,32 @@
             println("\(name) is being deinitialized")
         }
     }
-

    Person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。Person类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。

    -

    接下来的代码片段定义了三个类型为Person?的变量，用来按照代码片段中的顺序，为新的Person实例建立多个引用。由于这些变量是被定义为可选类型(Person?，而不是Person)，它们的值会被自动初始化为nil，目前还不会引用到Person类的实例。

    +

    Person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。Person类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。

    +

    接下来的代码片段定义了三个类型为Person?的变量，用来按照代码片段中的顺序，为新的Person实例建立多个引用。由于这些变量是被定义为可选类型（Person?，而不是Person），它们的值会被自动初始化为nil，目前还不会引用到Person类的实例。

        var reference1: Person?
     var reference2: Person?
     var reference3: Person?
-

    现在你可以创建Person类的新实例，并且将它赋值给三个变量其中的一个：

    +

    现在你可以创建Person类的新实例，并且将它赋值给三个变量其中的一个：

        reference1 = Person(name: "John Appleseed")
     // prints "John Appleseed is being initialized”
-

    应当注意到当你调用Person类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。

    -

    由于Person类的新实例被赋值给了reference1变量，所以reference1到Person类的新实例之间建立了一个强引用。正是因为这个强引用，ARC会保证Person实例被保持在内存中不被销毁。

    -

    如果你将同样的Person实例也赋值给其他两个变量，该实例又会多出两个强引用：

    +

    应当注意到当你调用Person类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。

    +

    由于Person类的新实例被赋值给了reference1变量，所以reference1到Person类的新实例之间建立了一个强引用。正是因为这个强引用，ARC 会保证Person实例被保持在内存中不被销毁。

    +

    如果你将同样的Person实例也赋值给其他两个变量，该实例又会多出两个强引用：

        reference2 = reference1
     reference3 = reference1
-

    现在这个Person实例已经有三个强引用了。

    -

    如果你通过给两个变量赋值nil的方式断开两个强引用(包括最先的那个强引用），只留下一个强引用，Person实例不会被销毁：

    +

    现在这个Person实例已经有三个强引用了。

    +

    如果你通过给两个变量赋值nil的方式断开两个强引用（）包括最先的那个强引用），只留下一个强引用，Person实例不会被销毁：

    reference2 = reference1
 reference3 = reference1
-

    ARC会在第三个，也即最后一个强引用被断开的时候，销毁Person实例，这也意味着你不再使用这个Person实例：

    +

    ARC 会在第三个，也即最后一个强引用被断开的时候，销毁Person实例，这也意味着你不再使用这个Person实例：

    reference3 = nil
 // prints "John Appleseed is being deinitialized"
-

    类实例之间的循环强引用

    -

    在上面的例子中，ARC会跟踪你所新创建的Person实例的引用数量，并且会在Person实例不再被需要时销毁它。

    +

    +

    类实例之间的循环强引用

    +

    在上面的例子中，ARC 会跟踪你所新创建的Person实例的引用数量，并且会在Person实例不再被需要时销毁它。

    然而，我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。

    -

    你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在解决类实例之间的循环强引用中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。

    -

    下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：Person和Apartment，用来建模公寓和它其中的居民:

    +

    你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在解决类实例之间的循环强引用中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。

    +

    下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：Person和Apartment，用来建模公寓和它其中的居民:

    class Person {
     let name: String
     init(name: String) { self.name = name }
@@ -662,42 +670,44 @@ class Apartment {
     var tenant: Person?
     deinit { println("Apartment #\(number) is being deinitialized") }
 }
-

    每一个Person实例有一个类型为String，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apartment属性是可选的，因为一个人并不总是拥有公寓。

    -

    类似的，每个Apartment实例有一个叫number，类型为Int的属性，并有一个可选的初始化为nil的tenant属性。tenant属性是可选的，因为一栋公寓并不总是有居民。

    -

    这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓Person和Apartment的实例是否像预期的那样被销毁。

    -

    接下来的代码片段定义了两个可选类型的变量john和number73,并分别被设定为下面的Apartment和Person的实例。这两个变量都被初始化为nil，并为可选的：

    +

    每一个Person实例有一个类型为String，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apartment属性是可选的，因为一个人并不总是拥有公寓。

    +

    类似的，每个Apartment实例有一个叫number，类型为Int的属性，并有一个可选的初始化为nil的tenant属性。tenant属性是可选的，因为一栋公寓并不总是有居民。

    +

    这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓Person和Apartment的实例是否像预期的那样被销毁。

    +

    接下来的代码片段定义了两个可选类型的变量john和number73,并分别被设定为下面的Apartment和Person的实例。这两个变量都被初始化为nil，并为可选的：

    var john: Person?
 var number73: Apartment?
-

    现在你可以创建特定的Person和Apartment实例并将类实例赋值给john和number73变量：

    +

    现在你可以创建特定的Person和Apartment实例并将类实例赋值给john和number73变量：

    john = Person(name: "John Appleseed")
 number73 = Apartment(number: 73)
-

    在两个实例被创建和赋值后，下图表面了强引用的关系。变量john现在有一个指向Person实例的强引用，而变量number73有一个指向Apartment实例的强引用：

    +

    在两个实例被创建和赋值后，下图表面了强引用的关系。变量john现在有一个指向Person实例的强引用，而变量number73有一个指向Apartment实例的强引用：

    -

    现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量john和number73中的实例，这样实例的属性才能被赋值：

    +

    现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量john和number73中的实例，这样实例的属性才能被赋值：

    john!.apartment = number73
 number73!.tenant = john

    在将两个实例联系在一起之后，强引用的关系如图所示：

    -

    不幸的是，将这两个实例关联在一起之后，一个循环强引用被创建了。Person实例现在有了一个指向Apartment实例的强引用，而Apartment实例也有了一个指向Person实例的强引用。因此，当你断开john和number73变量所持有的强引用时，引用计数并不会降为0，实例也不会被ARC销毁：

    +

    不幸的是，将这两个实例关联在一起之后，一个循环强引用被创建了。Person实例现在有了一个指向Apartment实例的强引用，而Apartment实例也有了一个指向Person实例的强引用。因此，当你断开john和number73变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：

    john = nil
 number73 = nil
-

    注意，当你把这两个变量设为nil时，没有任何一个析构函数被调用。强引用循环阻止了Person和Apartment类实例的销毁，并在你的应用程序中造成了内存泄漏。

    -

    在你将john和number73赋值为nil后，强引用关系如下图：

    +

    注意，当你把这两个变量设为nil时，没有任何一个析构函数被调用。强引用循环阻止了Person和Apartment类实例的销毁，并在你的应用程序中造成了内存泄漏。

    +

    在你将john和number73赋值为nil后，强引用关系如下图：

    -

    Person和Apartment实例之间的强引用关系保留了下来并且不会被断开。

    -

    解决实例之间的循环强引用

    -

    Swift提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用(weak reference)和无主引用(unowned reference)。

    +

    Person和Apartment实例之间的强引用关系保留了下来并且不会被断开。

    +

    +

    解决实例之间的循环强引用

    +

    Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和无主引用（unowned reference）。

    弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。

    -

    对于生命周期中会变为nil的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。

    -

    弱引用

    -

    弱引用不会牢牢保持住引用的实例，并且不会阻止ARC销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。

    -

    在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在无主引用中有描述。在上面Apartment的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。

    +

    对于生命周期中会变为nil的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。

    +

    弱引用

    +

    弱引用不会牢牢保持住引用的实例，并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。

    +

    在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在无主引用中有描述。在上面Apartment的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。

    -

    注意: 弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。

    +

    注意:

    +

    弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。

    -

    因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在Swift语言中推荐的用来表示可能没有值的类型。

    -

    因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC会在引用的实例被销毁后自动将其赋值为nil。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。

    -

    下面的例子跟上面Person和Apartment的例子一致，但是有一个重要的区别。这一次，Apartment的tenant属性被声明为弱引用：

    +

    因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。

    +

    因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为nil。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。

    +

    下面的例子跟上面Person和Apartment的例子一致，但是有一个重要的区别。这一次，Apartment的tenant属性被声明为弱引用：

    class Person {
     let name: String
     init(name: String) { self.name = name }
@@ -711,7 +721,7 @@ class Apartment {
     weak var tenant: Person?
     deinit { println("Apartment #\(number) is being deinitialized") }
 }
-

    然后跟之前一样，建立两个变量(john和number73)之间的强引用，并关联两个实例：

    +

    然后跟之前一样，建立两个变量（john和number73）之间的强引用，并关联两个实例：

    var john: Person?
 var number73: Apartment?
 
@@ -722,28 +732,29 @@ john!.apartment = number73
 number73!.tenant = john

    现在，两个关联在一起的实例的引用关系如下图所示：

    -

    Person实例依然保持对Apartment实例的强引用，但是Apartment实例只是对Person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向Person实例的强引用了：

    +

    Person实例依然保持对Apartment实例的强引用，但是Apartment实例只是对Person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向Person实例的强引用了：

    -

    由于再也没有指向Person实例的强引用，该实例会被销毁：

    +

    由于再也没有指向Person实例的强引用，该实例会被销毁：

    john = nil
 // prints "John Appleseed is being deinitialized"
-

    唯一剩下的指向Apartment实例的强引用来自于变量number73。如果你断开这个强引用，再也没有指向Apartment实例的强引用了：

    +

    唯一剩下的指向Apartment实例的强引用来自于变量number73。如果你断开这个强引用，再也没有指向Apartment实例的强引用了：

    -

    由于再也没有指向Apartment实例的强引用，该实例也会被销毁：

    +

    由于再也没有指向Apartment实例的强引用，该实例也会被销毁：

    number73 = nil
 // prints "Apartment #73 is being deinitialized"
-

    上面的两段代码展示了变量john和number73在被赋值为nil后，Person实例和Apartment实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。

    -

    无主引用

    -

    和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型(non-optional type)。你可以在声明属性或者变量时，在前面加上关键字unowned表示这是一个无主引用。

    -

    由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过ARC无法在实例被销毁后将无主引用设为nil，因为非可选类型的变量不允许被赋值为nil。

    +

    上面的两段代码展示了变量john和number73在被赋值为nil后，Person实例和Apartment实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。

    +

    无主引用

    +

    和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型（non-optional type）。你可以在声明属性或者变量时，在前面加上关键字unowned表示这是一个无主引用。

    +

    由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为nil，因为非可选类型的变量不允许被赋值为nil。

    -

    注意: 如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。

    +

    注意: +如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。

    还需要注意的是如果你试图访问实例已经被销毁的无主引用，程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。

    -

    下面的例子定义了两个类，Customer和CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会潜在的创造循环强引用。

    -

    Customer和CreditCard之间的关系与前面弱引用例子中Apartment和Person的关系截然不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，Customer类有一个可选类型的card属性，但是CreditCard类有一个非可选类型的customer属性。

    -

    此外，只能通过将一个number值和customer实例传递给CreditCard构造函数的方式来创建CreditCard实例。这样可以确保当创建CreditCard实例时总是有一个customer实例与之关联。

    -

    由于信用卡总是关联着一个客户，因此将customer属性定义为无主引用，用以避免循环强引用：

    +

    下面的例子定义了两个类，Customer和CreditCard，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会潜在的创造循环强引用。

    +

    Customer和CreditCard之间的关系与前面弱引用例子中Apartment和Person的关系截然不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，Customer类有一个可选类型的card属性，但是CreditCard类有一个非可选类型的customer属性。

    +

    此外，只能通过将一个number值和customer实例传递给CreditCard构造函数的方式来创建CreditCard实例。这样可以确保当创建CreditCard实例时总是有一个customer实例与之关联。

    +

    由于信用卡总是关联着一个客户，因此将customer属性定义为无主引用，用以避免循环强引用：

    class Customer {
     let name: String
     var card: CreditCard?
@@ -762,28 +773,28 @@ class CreditCard {
     }
     deinit { println("Card #\(number) is being deinitialized") }
 }
-

    下面的代码片段定义了一个叫john的可选类型Customer变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为nil。

    +

    下面的代码片段定义了一个叫john的可选类型Customer变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为nil。

    var john: Customer?
-

    现在你可以创建Customer类的实例，用它初始化CreditCard实例，并将新创建的CreditCard实例赋值为客户的card属性。

    +

    现在你可以创建Customer类的实例，用它初始化CreditCard实例，并将新创建的CreditCard实例赋值为客户的card属性。

    john = Customer(name: "John Appleseed")
 john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

    在你关联两个实例后，他们的引用关系如下图所示：

    -

    Customer实例持有对CreditCard实例的强引用，而CreditCard实例持有对Customer实例的无主引用。

    -

    由于customer的无主引用，当你断开john变量持有的强引用时，再也没有指向Customer实例的强引用了：

    +

    Customer实例持有对CreditCard实例的强引用，而CreditCard实例持有对Customer实例的无主引用。

    +

    由于customer的无主引用，当你断开john变量持有的强引用时，再也没有指向Customer实例的强引用了：

    -

    由于再也没有指向Customer实例的强引用，该实例被销毁了。其后，再也没有指向CreditCard实例的强引用，该实例也随之被销毁了：

    +

    由于再也没有指向Customer实例的强引用，该实例被销毁了。其后，再也没有指向CreditCard实例的强引用，该实例也随之被销毁了：

    john = nil
 // prints "John Appleseed is being deinitialized"
 // prints "Card #1234567890123456 is being deinitialized"
-

    最后的代码展示了在john变量被设为nil后Customer实例和CreditCard实例的构造函数都打印出了“销毁”的信息。

    -

    无主引用以及显式展开的可选属性

    +

    最后的代码展示了在john变量被设为nil后Customer实例和CreditCard实例的构造函数都打印出了“销毁”的信息。

    +

    无主引用以及显式展开的可选属性

    上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。

    -

    Person和Apartment的例子展示了两个属性的值都允许为nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。

    -

    Customer和CreditCard的例子展示了一个属性的值允许为nil，而另一个属性的值不允许为nil，并会潜在的产生循环强引用。这种场景最适合通过无主引用来解决。

    -

    然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后不能为nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用显示展开的可选属性。

    -

    这使两个属性在初始化完成后能被直接访问(不需要可选展开)，同事避免了循环引用。这一节将为你展示如何建立这种关系。

    -

    下面的例子定义了两个类，Country和City，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，Country类拥有一个capitalCity属性，而City类有一个country属性：

    +

    Person和Apartment的例子展示了两个属性的值都允许为nil，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。

    +

    Customer和CreditCard的例子展示了一个属性的值允许为nil，而另一个属性的值不允许为nil，并会潜在的产生循环强引用。这种场景最适合通过无主引用来解决。

    +

    然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后不能为nil。在这种场景中，需要一个类使用无主属性，而另外一个类使用显示展开的可选属性。

    +

    这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。这一节将为你展示如何建立这种关系。

    +

    下面的例子定义了两个类，Country和City，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，Country类拥有一个capitalCity属性，而City类有一个country属性：

    class Country {
     let name: String
     let capitalCity: City!
@@ -801,21 +812,22 @@ class City {
         self.country = country
     }
 }
-

    为了建立两个类的依赖关系，City的构造函数有一个Country实例的参数，并且将实例保存为country属性。

    -

    Country的构造函数调用了City的构造函数。然而，只有Country的实例完全初始化完后，Country的构造函数才能把self传给City的构造函数。(在两阶段构造函数中有具体描述)

    -

    为了满足这种需求，通过在类型结尾处加上感叹号(City!)的方式，将Country的capitalCity属性声明为显示展开的可选类型属性。这表示像其他可选类型一样，capitalCity属性的默认值为nil，但是不需要展开他的值就能访问它。(在显示展开的可选类型中有描述)

    -

    由于capitalCity默认值为nil，一旦Country的实例在构造函数中给name属性赋值后，整个初始化过程就完成了。这代表一旦name属性被后，Country的构造函数就能引用并传递显式的self。Country的构造函数在赋值capitalCity时，就能将self作为参数传递给City的构造函数。

    -

    以上的意义在于你可以通过一条语句同时创建Country和City的实例，而不产生循环强引用，并且capitalCity的属性能被直接访问，而不需要通过感叹号来展开它的可选值：

    +

    为了建立两个类的依赖关系，City的构造函数有一个Country实例的参数，并且将实例保存为country属性。

    +

    Country的构造函数调用了City的构造函数。然而，只有Country的实例完全初始化完后，Country的构造函数才能把self传给City的构造函数。（在两步构造函数中有具体描述）

    +

    为了满足这种需求，通过在类型结尾处加上感叹号（City!）的方式，将Country的capitalCity属性声明为显示展开的可选类型属性。这表示像其他可选类型一样，capitalCity属性的默认值为nil，但是不需要展开他的值就能访问它。（在显示展开的可选类型中有描述）

    +

    由于capitalCity默认值为nil，一旦Country的实例在构造函数中给name属性赋值后，整个初始化过程就完成了。这代表一旦name属性被后，Country的构造函数就能引用并传递显式的self。Country的构造函数在赋值capitalCity时，就能将self作为参数传递给City的构造函数。

    +

    以上的意义在于你可以通过一条语句同时创建Country和City的实例，而不产生循环强引用，并且capitalCity的属性能被直接访问，而不需要通过感叹号来展开它的可选值：

    var country = Country(name: "Canada", capitalName: "Ottawa")
 println("\(country.name)'s capital city is called \(country.capitalCity.name)")
 // prints "Canada's capital city is called Ottawa"
-

    在上面的例子中，使用显示展开可选值的意义在于满足了两个类构造函数的需求。capitalCity属性在初始化完成后，能作为非可选值使用同事还避免了循环强引用。

    +

    在上面的例子中，使用显示展开可选值的意义在于满足了两个类构造函数的需求。capitalCity属性在初始化完成后，能作为非可选值使用同事还避免了循环强引用。

    +

    闭包引起的循环强引用

    前面我们看到了循环强引用环是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破循环强引用。

    -

    循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod。这两种情况都导致了闭包 “捕获" self，从而产生了循环强引用。

    +

    循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod。这两种情况都导致了闭包 “捕获" self，从而产生了循环强引用。

    循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你也把一个引用赋值给了这个闭包。实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。

    -

    Swift提供了一种优雅的方法来解决这个问题，称之为闭包占用列表(closuer capture list)。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。

    -

    下面的例子为你展示了当一个闭包引用了self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类，用一种简单的模型表示HTML中的一个单独的元素：

    +

    Swift 提供了一种优雅的方法来解决这个问题，称之为闭包占用列表（closuer capture list）。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。

    +

    下面的例子为你展示了当一个闭包引用了self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类，用一种简单的模型表示 HTML 中的一个单独的元素：

    class HTMLElement {
 
     let name: String
@@ -839,54 +851,59 @@ println("\(country.name)'s capital city is called \(country.capitalCity
     }
 
 }
-

    HTMLElement类定义了一个name属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。HTMLElement还定义了一个可选属性text，用来设置和展现HTML元素的文本。

    -

    除了上面的两个属性，HTMLElement还定义了一个lazy属性asHTML。这个属性引用了一个闭包，将name和text组合成HTML字符串片段。该属性是() -> String类型，或者可以理解为“一个没有参数，返回String的函数”。

    -

    默认情况下，闭包赋值给了asHTML属性，这个闭包返回一个代表HTML标签的字符串。如果text值存在，该标签就包含可选值text；如果text不存在，该标签就不包含文本。对于段落元素，根据text是"some text"还是nil，闭包会返回"<p>some text</p>"或者"<p />"。

    -

    可以像实例方法那样去命名、使用asHTML属性。然而，由于asHTML是闭包而不是实例方法，如果你想改变特定元素的HTML处理的话，可以用自定义的闭包来取代默认值。

    +

    HTMLElement类定义了一个name属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。HTMLElement还定义了一个可选属性text，用来设置和展现 HTML 元素的文本。

    +

    除了上面的两个属性，HTMLElement还定义了一个lazy属性asHTML。这个属性引用了一个闭包，将name和text组合成 HTML 字符串片段。该属性是() -> String类型，或者可以理解为“一个没有参数，返回String的函数”。

    +

    默认情况下，闭包赋值给了asHTML属性，这个闭包返回一个代表 HTML 标签的字符串。如果text值存在，该标签就包含可选值text；如果text不存在，该标签就不包含文本。对于段落元素，根据text是"some text"还是nil，闭包会返回"<p>some text</p>"或者"<p />"。

    +

    可以像实例方法那样去命名、使用asHTML属性。然而，由于asHTML是闭包而不是实例方法，如果你想改变特定元素的 HTML 处理的话，可以用自定义的闭包来取代默认值。

    -

    注意: asHTML声明为lazy属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用asHTML。也就是说，在默认的闭包中可以使用self，因为只有当初始化完成以及self确实存在后，才能访问lazy属性。

    +

    注意:

    +

    asHTML声明为lazy属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用asHTML。也就是说，在默认的闭包中可以使用self，因为只有当初始化完成以及self确实存在后，才能访问lazy属性。

    -

    HTMLElement类只提供一个构造函数，通过name和text(如果有的话)参数来初始化一个元素。该类也定义了一个析构函数，当HTMLElement实例被销毁时，打印一条消息。

    -

    下面的代码展示了如何用HTMLElement类创建实例并打印消息。

    +

    HTMLElement类只提供一个构造函数，通过name和text（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当HTMLElement实例被销毁时，打印一条消息。

    +

    下面的代码展示了如何用HTMLElement类创建实例并打印消息。

    var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
 println(paragraph!.asHTML())
 // prints"hello, world"
    -

    注意: 上面的paragraph变量定义为可选HTMLElement，因此我们可以赋值nil给它来演示循环强引用。

    +

    注意:

    +

    上面的paragraph变量定义为可选HTMLElement，因此我们可以赋值nil给它来演示循环强引用。

    -

    不幸的是，上面写的HTMLElement类产生了类实例和asHTML默认值的闭包之间的循环强引用。循环强引用如下图所示：

    +

    不幸的是，上面写的HTMLElement类产生了类实例和asHTML默认值的闭包之间的循环强引用。循环强引用如下图所示：

    -

    实例的asHTML属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包占有了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包占有值的信息，请参考Capturing Values）。

    +

    实例的asHTML属性持有闭包的强引用。但是，闭包在其闭包体内使用了self（引用了self.name和self.text），因此闭包占有了self，这意味着闭包又反过来持有了HTMLElement实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包占有值的信息，请参考值捕获）。

    -

    注意: 虽然闭包多次使用了self，它只占有HTMLElement实例的一个强引用。

    +

    注意:

    +

    虽然闭包多次使用了self，它只占有HTMLElement实例的一个强引用。

    -

    如果设置paragraph变量为nil，打破它持有的HTMLElement实例的强引用，HTMLElement实例和它的闭包都不会被销毁，也是因为循环强引用：

    +

    如果设置paragraph变量为nil，打破它持有的HTMLElement实例的强引用，HTMLElement实例和它的闭包都不会被销毁，也是因为循环强引用：

    paragraph = nil
-

    注意HTMLElementdeinitializer中的消息并没有别打印，证明了HTMLElement实例并没有被销毁。

    +

    注意HTMLElementdeinitializer中的消息并没有别打印，证明了HTMLElement实例并没有被销毁。

    解决闭包引起的循环强引用

    在定义闭包时同时定义占有列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。占有列表定义了闭包体内占有一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个占有的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。

    -

    注意: 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或someInstance）成对组成。每一对都在花括号中，通过逗号分开。

    占有列表放置在闭包参数列表和返回类型之前：

    @lazy var someClosure: (Int, String) -> String = {
     [unowned self] (index: Int, stringToProcess: String) -> String in
     // closure body goes here
 }
-

    如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以占有列表放在闭包开始的地方，跟着是关键字in：

    +

    如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以占有列表放在闭包开始的地方，跟着是关键字in：

    @lazy var someClosure: () -> String = {
     [unowned self] in
     // closure body goes here
 }
-

    弱引用和无主引用

    +

    弱引用和无主引用

    当闭包和占有的实例总是互相引用时并且总是同时销毁时，将闭包内的占有定义为无主引用。

    -

    相反的，当占有引用有时可能会是nil时，将闭包内的占有定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包内检查他们是否存在。

    +

    相反的，当占有引用有时可能会是nil时，将闭包内的占有定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包内检查他们是否存在。

    -

    注意: 如果占有的引用绝对不会置为nil，应该用无主引用，而不是弱引用。

    +

    注意:

    +

    如果占有的引用绝对不会置为nil，应该用无主引用，而不是弱引用。

    -

    前面的HTMLElement例子中，无主引用是正确的解决循环强引用的方法。这样这样编写HTMLElement类来避免循环强引用：

    +

    前面的HTMLElement例子中，无主引用是正确的解决循环强引用的方法。这样这样编写HTMLElement类来避免循环强引用：

    class HTMLElement {
 
     let name: String
@@ -911,14 +928,14 @@ println(paragraph!.asHTML())
     }
 
 }
-

    上面的HTMLElement实现和之前的实现一致，只是在asHTML闭包中多了一个占有列表。这里，占有列表是[unowned self]，表示“用无主引用而不是强引用来占有self”。

    -

    和之前一样，我们可以创建并打印HTMLElement实例：

    +

    上面的HTMLElement实现和之前的实现一致，只是在asHTML闭包中多了一个占有列表。这里，占有列表是[unowned self]，表示“用无主引用而不是强引用来占有self”。

    +

    和之前一样，我们可以创建并打印HTMLElement实例：

    var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
 println(paragraph!.asHTML())
 // prints "<p>hello, world</p>"

    使用占有列表后引用关系如下图所示：

    -

    这一次，闭包以无主引用的形式占有self，并不会持有HTMLElement实例的强引用。如果将paragraph赋值为nil，HTMLElement实例将会被销毁，并能看到它的析构函数打印出的消息。

    +

    这一次，闭包以无主引用的形式占有self，并不会持有HTMLElement实例的强引用。如果将paragraph赋值为nil，HTMLElement实例将会被销毁，并能看到它的析构函数打印出的消息。

    paragraph = nil
 // prints "p is being deinitialized"
    @@ -966,6 +983,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/17_Optional_Chaining.html b/chapter2/17_Optional_Chaining.html index f3bf55c4..20d20b95 100644 --- a/chapter2/17_Optional_Chaining.html +++ b/chapter2/17_Optional_Chaining.html @@ -5,12 +5,12 @@ - 可选链 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,61 +587,76 @@
    -
    +
    -

    Optional Chaining

    +
    +

    翻译：Jasonbroker

    +

    校对：numbbbbb

    +
    +

    Optional Chaining

    +

    本页包含内容：

    +

    可选链（Optional Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的自判断性体现于请求或调用的目标当前可能为空（nil）。如果自判断的目标有值，那么调用就会成功；相反，如果选择的目标为空（nil），则这种调用将返回空（nil）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（nil）将导致整个链失效。

    -

    笔记： -Swift的自判断链和Objective-C中的消息为空有些相像，但是Swift可以使用在任意类型中，并且失败与否可以被检测到。

    +

    注意： +Swift 的自判断链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。

    +

    可选链可替代强制解析

    -

    通过在想调用的属性、方法、或子脚本的自判断值（optional value）（非空）后面放一个问号，可以定义一个可选链。这一点很像在自判断值后面放一个声明符号来强制拆得其封包内的值。他们的主要的区别在于当自判断值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。

    -

    为了反映可选链可以调用空（nil），不论你调用的属性、方法、子脚本等返回的值是不是自判断值，它的返回结果都是一个自判断值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。

    -

    调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个自判断值，当可选链调用成功时，一个应该返回Int的属性将会返回Int？。

    +

    通过在想调用的属性、方法、或子脚本的可选值（optional value）（非空）后面放一个问号，可以定义一个可选链。这一点很像在可选值后面放一个声明符号来强制拆得其封包内的值。他们的主要的区别在于当可选值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。

    +

    为了反映可选链可以调用空（nil），不论你调用的属性、方法、子脚本等返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。

    +

    调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回Int的属性将会返回Int?。

    下面几段代码将解释可选链和强制解析的不同。

    首先定义两个类Person和Residence。

    class Person {
-var residence: Residence?
+    var residence: Residence?
 }
 
 class Residence {
-var numberOfRooms = 1
+    var numberOfRooms = 1
 }
-

    Residence具有一个Int类型的numberOfRooms，其值为1。Person具有一个自判断residence属性，它的类型是Residence？。

    -

    如果你创建一个新的Person实例，它的residence属性由于是被定义为自判断型的，此属性将默认初始化为空：

    +

    Residence具有一个Int类型的numberOfRooms，其值为 1。Person具有一个自判断residence属性，它的类型是Residence？。

    +

    如果你创建一个新的Person实例，它的residence属性由于是被定义为自判断型的，此属性将默认初始化为空：

    let john = Person()
-

    如果你想使用声明符！强制解析获得这个人residence属性numberOfRooms属性值，将会引发运行时错误，因为这时没有可以供解析的residence值。

    +

    如果你想使用感叹号（!）强制解析获得这个人residence属性numberOfRooms属性值，将会引发运行时错误，因为这时没有可以供解析的residence值。

    let roomCount = john.residence!.numberOfRooms
-// this triggers a runtime error”
 //将导致运行时错误

    当john.residence不是nil时，会运行通过，且会将roomCount 设置为一个int类型的合理值。然而，如上所述，当residence为空时，这个代码将会导致运行时错误。

    -

    可选链提供了一种另一种获得numberOfRooms的方法。利用可选链，使用问号来代替原来！的位置：

    +

    可选链提供了一种另一种获得numberOfRooms的方法。利用可选链，使用问号来代替原来!的位置：

    if let roomCount = john.residence?.numberOfRooms {
     println("John's residence has \(roomCount) room(s).")
 } else {
     println("Unable to retrieve the number of rooms.")
 }
 // 打印 "Unable to retrieve the number of rooms.
-

    这告诉Swift来链接自判断residence？属性，如果residence存在则取回numberOfRooms的值。

    -

    因为这种尝试获得numberOfRooms的操作有可能失败，可选链会返回Int？类型值，或者称作“自判断Int”。当residence是空的时候（上例），选择Int将会为空，因此会出先无法访问numberOfRooms的情况。

    -

    要注意的是，即使numberOfRooms是非自判断Int（Int？）时这一点也成立。只要是通过可选链的请求就意味着最后numberOfRooms总是返回一个Int？而不是Int。

    +

    这告诉 Swift 来链接自判断residence?属性，如果residence存在则取回numberOfRooms的值。

    +

    因为这种尝试获得numberOfRooms的操作有可能失败，可选链会返回Int?类型值，或者称作“自判断Int”。当residence是空的时候（上例），选择Int将会为空，因此会出先无法访问numberOfRooms的情况。

    +

    要注意的是，即使numberOfRooms是非自判断Int（Int?）时这一点也成立。只要是通过可选链的请求就意味着最后numberOfRooms总是返回一个Int?而不是Int。

    你可以自己定义一个Residence实例给john.residence，这样它就不再为空了：

    john.residence = Residence()
-

    john.residence 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得numberOfRoooms，它将返回一个包含默认值1的Int？：

    +

    john.residence 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得numberOfRoooms，它将返回一个包含默认值 1 的Int?：

    if let roomCount = john.residence?.numberOfRooms {
-println("John's residence has \(roomCount) room(s).")
+    println("John's residence has \(roomCount) room(s).")
 } else {
     println("Unable to retrieve the number of rooms.")
 }
 // 打印 "John's residence has 1 room(s)"。
-

    为可选链定义模型类

    +

    +

    为可选链定义模型类

    你可以使用可选链来多层调用属性，方法，和子脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。

    后面的代码定义了四个将在后面使用的模型类，其中包括多层可选链。这些类是由上面的Person和Residence模型通过添加一个Room和一个Address类拓展来。

    Person类定义与之前相同。

    class Person {
-var residence: Residence?
+    var residence: Residence?
 }

    Residence类比之前复杂些。这次，它定义了一个变量 rooms，它被初始化为一个Room[]类型的空数组：

    class Residence {
@@ -660,13 +675,13 @@ var residence: Residence?

    因为Residence存储了一个Room实例的数组，它的numberOfRooms属性值不是一个固定的存储值，而是通过计算而来的。numberOfRooms属性值是由返回rooms数组的count属性值得到的。

    为了能快速访问rooms数组，Residence定义了一个只读的子脚本，通过插入数组的元素角标就可以成功调用。如果该角标存在，子脚本则将该元素返回。

    Residence中也提供了一个printNumberOfRooms的方法，即简单的打印房间个数。

    -

    最后，Residence定义了一个自判断属性叫address（address？）。Address类的属性将在后面定义。 +

    最后，Residence定义了一个自判断属性叫address（address?）。Address类的属性将在后面定义。 用于rooms数组的Room类是一个很简单的类，它只有一个name属性和一个设定room名的初始化器。

    class Room {
     let name: String
     init(name: String) { self.name = name }
 }
-

    这个模型中的最终类叫做Address。它有三个自判断属性他们额类型是String？。前面两个自判断属性buildingName和 buildingNumber作为地址的一部分，是定义某个建筑物的两种方式。第三个属性street，用于命名地址的街道名：

    +

    这个模型中的最终类叫做Address。它有三个自判断属性他们额类型是String?。前面两个自判断属性buildingName和 buildingNumber作为地址的一部分，是定义某个建筑物的两种方式。第三个属性street，用于命名地址的街道名：

    class Address {
     var buildingName: String?
     var buildingNumber: String?
@@ -681,9 +696,10 @@ var residence: Residence?
         }
     }
 }
-

    Address类还提供了一个buildingIdentifier的方法，它的返回值类型为String？。这个方法检查buildingName和buildingNumber的属性，如果buildingName有值则将其返回，或者如果buildingNumber有值则将其返回，再或如果没有一个属性有值，返回空。

    +

    Address类还提供了一个buildingIdentifier的方法，它的返回值类型为String?。这个方法检查buildingName和buildingNumber的属性，如果buildingName有值则将其返回，或者如果buildingNumber有值则将其返回，再或如果没有一个属性有值，返回空。

    +

    通过可选链调用属性

    -

    正如上面“ 可选链可替代强制解析”中所述，你可以利用可选链的自判断值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。

    +

    正如上面“ 可选链可替代强制解析”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。

    使用上述定义的类来创建一个人实例，并再次尝试后去它的numberOfRooms属性：

    let john = Person()
 if let roomCount = john.residence?.numberOfRooms {
@@ -693,21 +709,23 @@ if let roomCount = john.residence?.numberOfRooms {
 }
 // 打印 "Unable to retrieve the number of rooms。

    由于john.residence是空，所以这个可选链和之前一样失败了，但是没有运行时错误。

    +

    通过可选链调用方法

    -

    你可以使用可选链的来调用自判断值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。

    -

    Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法如下：

    +

    你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。

    +

    Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法如下：

    func printNumberOfRooms(){
     println(“The number of rooms is \(numberOfRooms)”)
 }

    这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型Void（参见Function Without Return Values）。

    -

    如果你利用可选链调用此方法，这个方法的返回值类型将是Void？，而不是Void，因为当通过可选链调用方法时返回值总是自判断类型（optional type）。，即使是这个方法本是没有定义返回值，你也可以使用if语句来检查是否能成功调用printNumberOfRooms方法：如果方法通过可选链调用成功，printNumberOfRooms的隐式返回值将会是Void，如果没有成功，将返回nil：

    +

    如果你利用可选链调用此方法，这个方法的返回值类型将是Void?，而不是Void，因为当通过可选链调用方法时返回值总是可选类型（optional type）。，即使是这个方法本是没有定义返回值，你也可以使用if语句来检查是否能成功调用printNumberOfRooms方法：如果方法通过可选链调用成功，printNumberOfRooms的隐式返回值将会是Void，如果没有成功，将返回nil：

    if john.residence?.printNumberOfRooms() {
     println("It was possible to print the number of rooms.")
 } else {
     println("It was not possible to print the number of rooms.")
 }
 // 打印 "It was not possible to print the number of rooms."。
-

    使用可选链调用子脚本

    +

    +

    使用可选链调用子脚本

    你可以使用可选链来尝试从子脚本获取值并检查子脚本的调用是否成功，然而，你不能通过可选链来设置子代码。

    注意： @@ -720,7 +738,7 @@ if let roomCount = john.residence?.numberOfRooms { println("Unable to retrieve the first room name.") } // 打印 "Unable to retrieve the first room name."。 -

    在子代码调用中可选链的问号直接跟在john.residence的后面，在子脚本括号的前面，因为john.residence是可选链试图获得的自判断值。

    +

    在子代码调用中可选链的问号直接跟在john.residence的后面，在子脚本括号的前面，因为john.residence是可选链试图获得的可选值。

    如果你创建一个Residence实例给john.residence，且在他的rooms数组中有一个或多个Room实例，那么你可以使用可选链通过Residence子脚本来获取在rooms数组中的实例了：

    let johnsHouse = Residence()
 johnsHouse.rooms += Room(name: "Living Room")
@@ -733,15 +751,16 @@ if let firstRoomName = john.residence?[0].name {
     println("Unable to retrieve the first room name.")
 }
 // 打印 "The first room name is Living Room."。
-

    连接多层链接

    -

    你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的自判断值更多的层。 +

    +

    连接多层链接

    +

    你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。 也就是说：

    -

    如果你试图获得的类型不是自判断类型，由于使用了可选链它将变成自判断类型。 -如果你试图获得的类型已经是自判断类型，由于可选链它也不会提高自判断性。

    +

    如果你试图获得的类型不是可选类型，由于使用了可选链它将变成可选类型。 +如果你试图获得的类型已经是可选类型，由于可选链它也不会提高自判断性。

    因此：

    -

    如果你试图通过可选链获得Int值，不论使用了多少层链接返回的总是Int？。 -相似的，如果你试图通过可选链获得Int？值，不论使用了多少层链接返回的总是Int？。

    -

    下面的例子试图获取john的residence属性里的address的street属性。这里使用了两层可选链来联系residence和address属性，他们两者都是自判断类型：

    +

    如果你试图通过可选链获得Int值，不论使用了多少层链接返回的总是Int?。 +相似的，如果你试图通过可选链获得Int?值，不论使用了多少层链接返回的总是Int?。

    +

    下面的例子试图获取john的residence属性里的address的street属性。这里使用了两层可选链来联系residence和address属性，他们两者都是可选类型：

    if let johnsStreet = john.residence?.address?.street {
     println("John's street name is \(johnsStreet).")
 } else {
@@ -749,7 +768,7 @@ if let firstRoomName = john.residence?[0].name {
 }
 // 打印 "Unable to retrieve the address.”。

    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属性设定一个实际值，你可以通过多层可选链来得到这个属性值。

    let johnsAddress = Address()
 johnsAddress.buildingName = "The Larches"
@@ -762,10 +781,11 @@ if let johnsStreet = john.residence?.address?.street {
     println("Unable to retrieve the address.")
 }
 // 打印 "John's street name is Laurel Street."。
-

    值得注意的是，“!”符的在定义address实例时的使用（john.residence.address）。john.residence属性是一个自判断类型，因此你需要在它获取address属性之前使用！解析以获得它的实际值。

    +

    值得注意的是，“!”符的在定义address实例时的使用（john.residence.address）。john.residence属性是一个可选类型，因此你需要在它获取address属性之前使用!解析以获得它的实际值。

    +

    链接自判断返回值的方法

    -

    前面的例子解释了如何通过可选链来获得自判断类型属性值。你也可以通过调用返回自判断类型值的方法并按需链接方法的返回值。

    -

    下面的例子通过可选链调用了Address类中的buildingIdentifier 方法。这个方法的返回值类型是String?。如上所述，这个方法在可选链调用后最终的返回值类型依然是String？：

    +

    前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过调用返回可选类型值的方法并按需链接方法的返回值。

    +

    下面的例子通过可选链调用了Address类中的buildingIdentifier 方法。这个方法的返回值类型是String?。如上所述，这个方法在可选链调用后最终的返回值类型依然是String?：

    if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
     println("John's building identifier is \(buildingIdentifier).")
 }
@@ -777,7 +797,7 @@ if let johnsStreet = john.residence?.address?.street {
 // 打印 "John's uppercase building identifier is THE LARCHES."。

    注意： -在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的自判断值是buildingIdentifier方法的返回值，不是buildingIdentifier方法本身。

    +在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是buildingIdentifier方法的返回值，不是buildingIdentifier方法本身。

    @@ -824,6 +844,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/18_Type_Casting.html b/chapter2/18_Type_Casting.html index 78416fba..14a5db17 100644 --- a/chapter2/18_Type_Casting.html +++ b/chapter2/18_Type_Casting.html @@ -5,12 +5,12 @@ - 类型检查 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,22 +587,28 @@
    -
    +
    -

    类型检查（Type Casting）

    +
    +

    翻译：xiehurricane

    +

    校对：happyming

    +
    +

    类型检查（Type Casting）

    -

    （ps：为了方便各位检验所以保留了英文，可删。） - 类型检查是一种检查类实例的方式，并且哦或者也是让实例作为它的父类或者子类的一种方式。

    -

    Type casting is a way to check the type of an instance, and/or to treat that instance as if it is a different superclass or subclass from somewhere else in its own class hierarchy.

    -

    类型检查在Swift中使用is 和 as操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。

    -

    Type casting in Swift is implemented with the is and as operators. These two operators provide a simple and expressive way to check the type of a value or cast a value to a different type.

    -

    你也可以用来检查一个类是否实现了某个协议，就像在 Protocols》Checking for Protocol Conformance部分讲述的一样。

    -

    You can also use type casting to check whether a type conforms to a protocol, as described in Checking for Protocol Conformance.

    -

    定义一个类层次作为例子Defining a Class Hierarchy for Type Casting

    -

    你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个array包含了几个这些类的实例，作为类型检查的例子。

    -

    You can use type casting with a hierarchy of classes and subclasses to check the type of a particular class instance and to cast that instance to another class within the same hierarchy. The three code snippets below define a hierarchy of classes and an array containing instances of those classes, for use in an example of type casting.

    -

    第一个代码片段定义了一个新的基础类MediaItem。这个类为任何出现在数字媒体库的项提供基础功能。特别的，它声明了一个 String 类型的 name 属性，和一个init name初始化器。（它假定所有的媒体项都有个名称。）

    -

    The first snippet defines a new base class called MediaItem. This class provides basic functionality for any kind of item that appears in a digital media library. Specifically, it declares a name property of type String, and an init name initializer. (It is assumed that all media items, including all movies and songs, will have a name.)

    +

    本页包含内容：

    + +

    类型检查是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。

    +

    类型检查在 Swift 中使用is 和 as操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。

    +

    你也可以用来检查一个类是否实现了某个协议，就像在 Protocols Checking for Protocol Conformance部分讲述的一样。

    +

    +

    定义一个类层次作为例子

    +

    你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。

    +

    第一个代码片段定义了一个新的基础类MediaItem。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 String 类型的 name 属性，和一个init name初始化器。（它假定所有的媒体项都有个名称。）

    class MediaItem {
     var name: String
     init(name: String) {
@@ -610,24 +616,15 @@
     }
 }

    下一个代码段定义了 MediaItem 的两个子类。第一个子类Movie，在父类（或者说基类）的基础上增加了一个 director（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 artist（艺术家） 属性，和相应的初始化器：

    -

    The next snippet defines two subclasses of MediaItem. The first subclass, Movie, encapsulates additional information about a movie or film. It adds a director property on top of the base MediaItem class, with a corresponding initializer. The second subclass, Song, adds an artist property and initializer on top of the base class:

    -
    class Movie: MediaItem {
-    var director: String
-    init(name: String, director: String) {
-        self.director = director
-        super.init(name: name)
-    }
-}
-
-class Song: MediaItem {
+
    class Song: MediaItem {
     var artist: String
     init(name: String, artist: String) {
         self.artist = artist
         super.init(name: name)
     }
 }
-
      最后一个代码段创建了一个array常量 library ，包含两个Movie实例和三个Song实例。library的类型是在它被初始化时根据它的array标记符和里面的内容（ps: literal： 标记符其实就是指“[”和“]”，虽然苹果官方的翻译里翻译为字面当总感觉不好理解，有点奇怪。不如翻译为标记符）推断来的。Swift的类型检测器能够演绎出Movie 和 Song 有共同的父类 MediaItem ，所以它推断出 MediaItem[] 类作为 library 的类型。
    
-
      The final snippet creates a constant array called library, which contains two Movie instances and three Song instances. The type of the library array is inferred by initializing it with the contents of an array literal. Swift’s type checker is able to deduce that Movie and Song have a common superclass of MediaItem, and so it infers a type of MediaItem[] for the library array:
    
+

    最后一个代码段创建了一个数组常量 library + ，包含两个Movie实例和三个Song实例。library的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出Movie 和 Song 有共同的父类 MediaItem ，所以它推断出 MediaItem[] 类作为 library 的类型。

    let library = [
 Movie(name: "Casablanca", director: "Michael Curtiz"),
 Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
@@ -636,13 +633,11 @@ Song(name: "The One And Only", artist: "Chesney Hawkes"),
 Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
 ]
 // the type of "library" is inferred to be MediaItem[]
-

    在幕后library 里存储的项依然是 Movie 和 Song 类型的，但是，若你迭代它，取出的实例会是 MediaItem 类型的，而不是 Movie 和 Song 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。

    -

    The items stored in library are still Movie and Song instances behind the scenes. However, if you iterate over the contents of this array, the items you receive back are typed as MediaItem, and not as Movie or Song. In order to work with them as their native type, you need to check their type, or downcast them to a different type, as described below.

    -

    检查类型 Checking Type

    +

    在幕后library 里存储的媒体项依然是 Movie 和 Song 类型的，但是，若你迭代它，取出的实例会是 MediaItem 类型的，而不是 Movie 和 Song 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。

    +

    +

    检查类型

    用类型检查操作符(is)来检查一个实例是否属于特定子类型。类型检查操作符返回 true 若实例属于那个子类型，若不属于返回 false 。

    -

    Use the type check operator (is) to check whether an instance is of a certain subclass type. The type check operator returns true if the instance is of that subclass type and false if it is not.

    -

    下面的例子定义了连个变量，movieCount 和 songCount，用来计算数组library 中 Movie 和 Song 类型的实例数量。

    -

    The example below defines two variables, movieCount and songCount, which count the number of Movie and Song instances in the library array:

    +

    下面的例子定义了两个变量，movieCount 和 songCount，用来计算数组library 中 Movie 和 Song 类型的实例数量。

    var movieCount = 0
 var songCount = 0
 
@@ -657,23 +652,18 @@ for item in library {
 println("Media library contains \(movieCount) movies and \(songCount) songs")
 // prints "Media library contains 2 movies and 3 songs"

    示例迭代了数组 library 中的所有项。每一次， for-in 循环设置 - item 常量的值为数组中的下一个 MediaItem。

    -

    This example iterates through all items in the library array. On each pass, the for-in loop sets the item constant to the next MediaItem in the array.

    -

    若当前 MediaItem 是一个 Movie 类型的实例， item is Movie 返回 true，相反返回 false。同样的，item is Song检查item是否为Song类型的实例。在循环末尾，movieCount 和 songCount的值就是被找到属于各自的类型的实例数量。

    -

    item is Movie returns true if the current MediaItem is a Movie instance and false if it is not. Similarly, item is Song checks whether the item is a Song instance. At the end of the for-in loop, the values of movieCount and songCount contain a count of how many MediaItem instances were found of each type.

    -

    向下转型（简称下转） Downcasting

    + item 为数组中的下一个 MediaItem。

    +

    若当前 MediaItem 是一个 Movie 类型的实例， item is Movie 返回 + true，相反返回 false。同样的，item is + Song检查item是否为Song类型的实例。在循环结束后，movieCount 和 songCount的值就是被找到属于各自的类型的实例数量。

    +

    +

    向下转型（Downcasting）

    某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型检查操作符(as)

    -

    A constant or variable of a certain class type may actually refer to an instance of a subclass behind the scenes. Where you believe this is the case, you can try to downcast to the subclass type with the type cast operator (as).

    因为向下转型可能会失败，类型检查操作符带有两种不同形式。可选形式（ optional form） as? 返回一个你试图下转成的类型的可选值（optional value）。强制形式 as 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。

    -

    Because downcasting can fail, the type cast operator comes in two different forms. The optional form, as?, returns an optional value of the type you are trying to downcast to. The forced form, as, attempts the downcast and force-unwraps the result as a single compound action.

    当你不确定下转可以成功时，用类型检查的可选形式(as?)。可选形式的类型检查总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 nil 。这使你能够检查下转是否成功。

    -

    Use the optional form of the type cast operator (as?) when you are not sure if the downcast will succeed. This form of the operator will always return an optional value, and the value will be nil if the downcast was not possible. This enables you to check for a successful downcast.

    -

    只有你可以确定下转一定会成功时，才使用强制形式。当你试图下转为一个不正确的类型时，强制形式的类型检查会触发一个runtime error。

    -

    Use the forced form of the type cast operator (as) only when you are sure that the downcast will always succeed. This form of the operator will trigger a runtime error if you try to downcast to an incorrect class type.

    -

    下面的例子，迭代了library里的每一个 MediaItem ，并打印出适当的描述。要这样做，item需要真正作为Movie 或 Song的类型来使用。不仅仅是作为 MediaItem。为了能够使用Movie 或 Song的 director 或 artist属性，这是必要的。

    -

    The example below iterates over each MediaItem in library, and prints an appropriate description for each item. To do this, it needs to access each item as a true Movie or Song, and not just as a MediaItem. This is necessary in order for it to be able to access the director or artist property of a Movie or Song for use in the description.

    -

    在这个示例中，数组中的每一个item可能是 Movie 或 Song。 事前你不知道每个item的真实类型，所以这里使用可选形式的类型检查 (as?)去检查循环里的每次下转。

    -

    In this example, each item in the array might be a Movie, or it might be a Song. You don’t know in advance which actual class to use for each item, and so it is appropriate to use the optional form of the type cast operator (as?) to check the downcast each time through the loop:

    +

    只有你可以确定下转一定会成功时，才使用强制形式。当你试图下转为一个不正确的类型时，强制形式的类型检查会触发一个运行时错误。

    +

    下面的例子，迭代了library里的每一个 MediaItem ，并打印出适当的描述。要这样做，item需要真正作为Movie 或 Song的类型来使用。不仅仅是作为 MediaItem。为了能够使用Movie 或 Song的 director 或 artist属性，这是必要的。

    +

    在这个示例中，数组中的每一个item可能是 Movie 或 Song。 事前你不知道每个item的真实类型，所以这里使用可选形式的类型检查 （as?）去检查循环里的每次下转。

    for item in library {
     if let movie = item as? Movie {
         println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -687,56 +677,41 @@ println("Media library contains \(movieCount) movies and \(songCount) songs
 // Movie: 'Citizen Kane', dir. Orson Welles
 // Song: 'The One And Only', by Chesney Hawkes
 // Song: 'Never Gonna Give You Up', by Rick Astley
-

    示例首先试图将 item 下转为 Movie。因为 item 是一个 MediaItem 类型的实例，它可能是一个Movie；同样，它可能是一个 Song，或者仅仅是基类 MediaItem。因为不确定，as?形式试图下转时返还一个可选值。 item as Movie 的返回值是Movie?类型或 “optional Movie”。

    -

    The example starts by trying to downcast the current item as a Movie. Because item is a MediaItem instance, it’s possible that it might be a Movie; equally, it’s also possible that it might a Song, or even just a base MediaItem. Because of this uncertainty, the as? form of the type cast operator returns an optional value when attempting to downcast to a subclass type. The result of item as Movie is of type Movie?, or “optional Movie”.

    -

    当应用在两个Song实例时，下转为 Movie 失败。为了处理这种情况，上面的实例使用了可选绑定（optional binding）来检查optional Movie真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“if let movie = item as? Movie”,可以这样解读：

    -

    Downcasting to Movie fails when applied to the two Song instances in the library array. To cope with this, the example above uses optional binding to check whether the optional Movie actually contains a value (that is, to find out whether the downcast succeeded.) This optional binding is written “if let movie = item as? Movie”, which can be read as:

    -

    “尝试将 item 转为 Movie类型。若成功，设置一个新的临时常量 movie 来存储返回的optional Movie”

    -

    “Try to access item as a Movie. If this is successful, set a new temporary constant called movie to the value stored in the returned optional Movie.”

    +

    示例首先试图将 item 下转为 Movie。因为 item 是一个 MediaItem + 类型的实例，它可能是一个Movie；同样，它可能是一个 Song，或者仅仅是基类 + MediaItem。因为不确定，as?形式在试图下转时将返还一个可选值。 item as Movie 的返回值是Movie?类型或 “optional Movie”。

    +

    当下转为 Movie 应用在两个 Song + 实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 Movie真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“if let movie = item as? Movie”，可以这样解读：

    +

    “尝试将 item 转为 Movie类型。若成功，设置一个新的临时常量 movie 来存储返回的可选Movie”

    若下转成功，然后movie的属性将用于打印一个Movie实例的描述，包括它的导演的名字director。当Song被找到时，一个相近的原理被用来检测 Song 实例和打印它的描述。

    -

    If the downcasting succeeds, the properties of movie are then used to print a description for that Movie instance, including the name of its director. A similar principle is used to check for Song instances, and to print an appropriate description (including artist name) whenever a Song is found in the library.

    -
    注意
-
-转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
-
-NOTE
-
-Casting does not actually modify the instance or change its values. The underlying instance remains the same; it is simply treated and accessed as an instance of the type to which it has been cast.
-

    Any和AnyObject的转换 Type Casting for Any and AnyObject

    +
    +

    注意：

    +

    转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。

    +
    +

    +

    Any和AnyObject的类型检查

    Swift为不确定类型提供了两种特殊类型别名：

    • AnyObject可以代表任何class类型的实例。

    • Any可以表示任何类型，除了方法类型（function types）。

      -

      Swift provides two special type aliases for working with non-specific types:

    -
      -
    • AnyObject can represent an instance of any class type.
      • -

    • Any can represent an instance of any type at all, apart from function types.

      -
      注意
-
-只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的。
-
-NOTE
-
-Use Any and AnyObject only when you explicitly need the behavior and capabilities they provide. It is always better to be specific about the types you expect to work with in your code.
-
      • -
    -

    AnyObject类型

    -

    当需要在工作中使用Cocoa APIs，它一般接收一个AnyObject[]类型的数组，或者说“一个任何对象类型的数组”。这是因为OC没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的API信息提供的这样一个数组中的对象的类型。

    -

    When working with Cocoa APIs, it is common to receive an array with a type of AnyObject[], or “an array of values of any object type”. This is because Objective-C does not have explicitly typed arrays. However, you can often be confident about the type of objects contained in such an array just from the information you know about the API that provided the array.

    -

    在这些情况下，你可以使用强制形式的类型检查(as)来下转在数组中的每一项到比 AnyObject 更明确的类型，不需要可选解包（optional unwrapping）。

    -

    In these situations, you can use the forced version of the type cast operator (as) to downcast each item in the array to a more specific class type than AnyObject, without the need for optional unwrapping.

    +
    +

    注意：

    +

    只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的。

    +
    +

    AnyObject类型

    +

    当需要在工作中使用 Cocoa + APIs，它一般接收一个AnyObject[]类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。

    +

    在这些情况下，你可以使用强制形式的类型检查(as)来下转在数组中的每一项到比 AnyObject 更明确的类型，不需要可选解析（optional unwrapping）。

    下面的示例定义了一个 AnyObject[] 类型的数组并填入三个Movie类型的实例：

    -

    The example below defines an array of type AnyObject[] and populates this array with three instances of the Movie class:

    let someObjects: AnyObject[] = [
     Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"),
     Movie(name: "Moon", director: "Duncan Jones"),
     Movie(name: "Alien", director: "Ridley Scott")
 ]

    因为知道这个数组只包含 Movie 实例，你可以直接用(as)下转并解包到不可选的Movie类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。

    -

    Because this array is known to contain only Movie instances, you can downcast and unwrap directly to a non-optional Movie with the forced version of the type cast operator (as):

    for object in someObjects {
     let movie = object as Movie
     println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -744,17 +719,15 @@ Use Any and AnyObject only when you explicitly need the behavior and capabilitie
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
 // Movie: 'Alien', dir. Ridley Scott
-

    为了变为一个更短的形式，下转someObjects类型成功 Movie[] 类型代替下转每一项。

    -

    For an even shorter form of this loop, downcast the someObjects array to a type of Movie[] instead of downcasting each item:

    +

    为了变为一个更短的形式，下转someObjects数组为Movie[]类型来代替下转每一项方式。

    for movie in someObjects as Movie[] {
     println("Movie: '\(movie.name)', dir. \(movie.director)")
 }
 // Movie: '2001: A Space Odyssey', dir. Stanley Kubrick
 // Movie: 'Moon', dir. Duncan Jones
 // Movie: 'Alien', dir. Ridley Scott
-

    Any类型

    -

    这里有个示例，使用 Any 类型来和混合的不同类型一起工作，包括非class类型。它创建了一个可以存储Any类型的数组 things。

    -

    Here’s an example of using Any to work with a mix of different types, including non-class types. The example creates an array called things, which can store values of type Any:

    +

    Any类型

    +

    这里有个示例，使用 Any 类型来和混合的不同类型一起工作，包括非class类型。它创建了一个可以存储Any类型的数组 things。

    var things = Any[]()
 
 things.append(0)
@@ -764,10 +737,8 @@ things.append(3.14159)
 things.append("hello")
 things.append((3.0, 5.0))
 things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
-

    things 数组包含两个 Int 值，2个 Double 值，1个 String 值，一个元组 (Double, Double) ，Ivan Reitman导演的电影“Ghostbusters”。

    -

    The things array contains two Int values, two Double values, a String value, a tuple of type (Double, Double), and the movie “Ghostbusters”, directed by Ivan Reitman.

    +

    things 数组包含两个 Int 值，2个 Double 值，1个 String 值，一个元组 (Double, Double) ，Ivan Reitman 导演的电影“Ghostbusters”。

    你可以在 switch cases里用is 和 as 操作符来发觉只知道是 Any 或 AnyObject的常量或变量的类型。 下面的示例迭代 things数组中的每一项的并用switch语句查找每一项的类型。这几种switch语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：

    -

    You can use the is and as operators in a switch statement’s cases to discover the specific type of a constant or variable that is known only to be of type Any or AnyObject. The example below iterates over the items in the things array and queries the type of each item with a switch statement. Several of the switch statement’s cases bind their matched value to a constant of the specified type to enable its value to be printed:

    for thing in things {
     switch thing {
     case 0 as Int:
@@ -799,14 +770,11 @@ things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman
 // an (x, y) point at 3.0, 5.0
 // a movie called 'Ghostbusters', dir. Ivan Reitman

    。

    -
    注意
+
    
+
    注意：
    
+
    在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。
    
+
    
 
-在一个switch语句的case中使用强制形式的类型检查操作符(as, 而不是 as?) 来检查和转换到一个规定的类型。在switch case 语句的内容中这种检查总是安全的。
-
-NOTE
-
-The cases of a switch statement use the forced version of the type cast operator (as, not as?) to check and cast to a specific type. This check is always safe within the context of a switch case statement.
-
    @@ -818,7 +786,7 @@ The cases of a switch statement use the forced version of the type cast operator - +
    • @@ -851,6 +819,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/19_Nested_Types.html b/chapter2/19_Nested_Types.html index 0c3b4752..2dceade3 100644 --- a/chapter2/19_Nested_Types.html +++ b/chapter2/19_Nested_Types.html @@ -5,12 +5,12 @@ - 嵌套类型 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,17 +587,22 @@
    -
    +
    -

    类型嵌套

    +
    +

    翻译：Lin-H

    +

    校对：shinyzhu

    +
    +

    类型嵌套

    本页包含内容：

    枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义类型嵌套，可以在枚举类型、类和结构体中定义支持嵌套的类型。

    要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。

    +

    类型嵌套实例

    下面这个例子定义了一个结构体BlackjackCard(二十一点)，用来模拟BlackjackCard中的扑克牌点数。BlackjackCard结构体包含2个嵌套定义的枚举类型Suit 和 Rank。

    在BlackjackCard规则中，Ace牌可以表示1或者11，Ace牌的这一特征用一个嵌套在枚举型Rank的结构体Values来表示。

    @@ -647,6 +652,7 @@ println("theAceOfSpades: \(theAceOfSpades.description)") // 打印出 "theAceOfSpades: suit is ♠, value is 1 or 11"

    尽管Rank和Suit嵌套在BlackjackCard中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中description属性能正确得输出对Ace牌有1和11两个值。

    +

    类型嵌套的引用

    在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名：

    let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
@@ -697,6 +703,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/20_Extensions.html b/chapter2/20_Extensions.html
index 93d10370..6c4983d5 100644
--- a/chapter2/20_Extensions.html
+++ b/chapter2/20_Extensions.html
@@ -5,12 +5,12 @@
         
         
         
-        扩展 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
    
+    
    
     
    
     
     
@@ -98,7 +98,7 @@
     
     
    
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
    
 
    
 
@@ -119,7 +119,7 @@
         
 
         
  • 
-             Introduction
+             序
         
    • 
         
     
@@ -331,7 +331,7 @@
         
  • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,23 +587,27 @@
 
                 
    
                 
-                    
    
+                    
    
                     
-                        
    扩展（Extensions）
    
+                        
    
+
    翻译：lyuka
    
+
    校对：Hawstein
    
+
    
+
    扩展（Extensions）
    
 
    
 
    本页包含内容：
    
 
-
    扩展就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即逆向建模）。扩展和Objective-C中的分类(categories)类似。（不过与Objective-C不同的是，Swift的扩展没有名字。）
    
-
    Swift中的扩展可以：
    
+
    扩展就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即逆向建模）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。）
    
+
    Swift 中的扩展可以：
    
 
      
-
    • 添加计算属性和计算静态属性
      • 
+
    • 添加计算型属性和计算静态属性
      • 
 
    • 定义实例方法和类型方法
      • 
 
    • 提供新的构造器
      • 
 
    • 定义下标
      • 
@@ -611,204 +615,195 @@
 
    • 使一个已有类型符合某个接口
      • 
 
    
 
    
-
    注意
-如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
    
+
    注意：
    
+
    如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
    
 
    
-
    扩展语法
    
+
    
+
    扩展语法（Extension Syntax）
    
 
    声明一个扩展使用关键字extension：
    
-
    extension SomeType{
-    // new functionality to add to SomeType goes here
+
    extension SomeType {
+    // 加到SomeType的新功能写到这里
 }
-
    
-
    一个扩展可以扩展一个已有类型，使其能够适配一个或多个接口。当这种情况发生时，接口的名字应该完全按照类或结构体的名字的方式进行书写：
    
-
    extension SomeType: SomeProtocol, AnotherProctocol{
-    // implementation of protocol requirments goes here
+
    一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，接口的名字应该完全按照类或结构体的名字的方式进行书写：
    
+
    extension SomeType: SomeProtocol, AnotherProctocol {
+    // 协议实现写到这里
 }
-
    
-
    按照这种方式添加的接口一致性被称之为给扩展添加接口一致性(Protocal Conformance)
    
-
    计算属性
    
-
    扩展可以向已有类型添加计算实例属性和计算类型属性。下面的例子向Swift的内建Double类型添加了5个计算实例属性，从而提供与距离单位协作的基本支持。
    
-
    extension Double{
-    var km: Double { return self * 1_000.0 }
-    var m : Double { return self }
-    var cm: Double { return self / 100.0 }
-    var mm: Double { return self / 1_000.0 }
-    var ft: Double { return self / 3.28084 }
+
    按照这种方式添加的协议遵循者（protocol conformance）被称之为在扩展中添加协议遵循者
    
+
    
+
    计算型属性（Computed Properties）
    
+
    扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建Double类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。
    
+
    extension Double {
+    var km: Double { return self * 1_000.0 }
+    var m : Double { return self }
+    var cm: Double { return self / 100.0 }
+    var mm: Double { return self / 1_000.0 }
+    var ft: Double { return self / 3.28084 }
 }
-let oneInch = 25.4.mm
-println("One inch is \(oneInch) meters")
-// prints "One inch is 0.0254 meters"
-let threeFeet = 3.ft
-println("Three feet is \(threeFeet) meters")
-// prints "Three feet is 0.914399970739201 meters"
-
    
-
    这些计算属性表达的含义是把一个Double型的值看作是某单位下的长度值。即使它们被实现为计算属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。
    
-
    在上述例子中，一个Double型的值1.0被用来表示“1米”。这就是为什么m计算属性返回self——表达式1.m被认为是计算1.0的Double值。
    
-
    其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以km计算属性要把值乘以1_000.00来转化成单位米下的数值。类似地，1米有3.28024英尺，所以ft计算属性要把对应的Double值除以3.28024来实现英尺到米的单位换算。
    
-
    这些属性是只读的计算属性，所有从简考虑它们不用get关键字表示。它们的返回值是Double型，而且可以用于所有接受Double的数学计算中：
    
-
    let aMarathon = 42.km + 195.m
-println("A marathon is \(aMarathon) meters long")
-// prints "A marathon is 42495.0 meters long"
-
    
-
    
-
    注意
-扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
    
+let oneInch = 25.4.mm
+println("One inch is \(oneInch) meters")
+// 打印输出："One inch is 0.0254 meters"
+let threeFeet = 3.ft
+println("Three feet is \(threeFeet) meters")
+// 打印输出："Three feet is 0.914399970739201 meters"
+
    这些计算属性表达的含义是把一个Double型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。
    
+
    在上述例子中，一个Double型的值1.0被用来表示“1米”。这就是为什么m计算型属性返回self——表达式1.m被认为是计算1.0的Double值。
    
+
    其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以km计算型属性要把值乘以1_000.00来转化成单位米下的数值。类似地，1米有3.28024英尺，所以ft计算型属性要把对应的Double值除以3.28024来实现英尺到米的单位换算。
    
+
    这些属性是只读的计算型属性，所有从简考虑它们不用get关键字表示。它们的返回值是Double型，而且可以用于所有接受Double的数学计算中：
    
+
    let aMarathon = 42.km + 195.m
+println("A marathon is \(aMarathon) meters long")
+// 打印输出："A marathon is 42495.0 meters long"
+
    
+
    注意：
    
+
    扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
    
 
    
-
    构造器
    
+
    
+
    构造器（Initializers）
    
 
    扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。
    
 
    
-
    注意
-如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和成员级构造器(memberwise initializers)。
+
    注意：
    
+
    如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和成员级构造器(memberwise initializers)。
 正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
    
 
    
 
    下面的例子定义了一个用于描述几何矩形的定制结构体Rect。这个例子同时定义了两个辅助结构体Size和Point，它们都把0.0作为所有属性的默认值：
    
-
    struct Size{
-    var width = 0.0, height = 0.0
+
    struct Size {
+    var width = 0.0, height = 0.0
 }
-struct Point{
-    var x = 0.0, y = 0.0
+struct Point {
+    var x = 0.0, y = 0.0
 }
-struct Rect{
-    var origin = Point()
-    var size = Size()
+struct Rect {
+    var origin = Point()
+    var size = Size()
 }
-
    
-
    因为结构体Rect提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的Rect实例：
    
-
    let defaultRect = Rect()
-let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0), 
-    size: Size(width: 5.0, height: 5.0))
-
    
-
    你可以提供一个额外的使用特殊中心点和大小的构造器来扩展Rect结构体：
    
-
    extension Rect{
-    init(center: Point, size: Size){
-        let originX = center.x - (size.width / 2)
-        let originY = center.y - (size.height / 2)
+
    因为结构体Rect提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的Rect实例：
    
+
    let defaultRect = Rect()
+let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
+    size: Size(width: 5.0, height: 5.0))
+
    你可以提供一个额外的使用特殊中心点和大小的构造器来扩展Rect结构体：
    
+
    extension Rect {
+    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)
     }
 }
-
    
-
    这个新的构造器首先根据提供的center和size值计算一个合适的原点。然后调用该结构体自动的成员构造器init(origin:size:)，该构造器将新的原点和大小存到了合适的属性中：
    
-
    let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
-    size: Size(width: 3.0, height: 3.0))
-// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)
-
    
-
    
-
    注意
-如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。
    
+
    这个新的构造器首先根据提供的center和size值计算一个合适的原点。然后调用该结构体自动的成员构造器init(origin:size:)，该构造器将新的原点和大小存到了合适的属性中：
    
+
    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)
+
    
+
    注意：
    
+
    如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。
    
 
    
-
    方法
    
+
    
+
    方法（Methods）
    
 
    扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向Int类型添加一个名为repetitions的新实例方法：
    
-
    extension Int{
-    func repetitions(task: () -> ()){
-        for i in 0..self{
+
    extension Int {
+    func repetitions(task: () -> ()) {
+        for i in 0..self {
             task()
         }
     }
 }
-
    
-
    这个repetitions方法使用了一个() -> ()类型的单参数（single argument），表明函数没有参数而且没有返回值。
    
+
    这个repetitions方法使用了一个() -> ()类型的单参数（single argument），表明函数没有参数而且没有返回值。
    
 
    定义该扩展之后，你就可以对任意整数调用repetitions方法,实现的功能则是多次执行某任务：
    
-
    3.repetitions({
-    println("Hello!")
+
    3.repetitions({
+    println("Hello!")
     })
-// Hello!
-// Hello!
-// Hello!
-
    
-
    可以使用trailing闭包使调用更加简洁：
    
-
    3.repetitions{
-    println("Goodbye!")
+// Hello!
+// Hello!
+// Hello!
+
    可以使用 trailing 闭包使调用更加简洁：
    
+
    3.repetitions{
+    println("Goodbye!")
 }
-// Goodbye!
-// Goodbye!
-// Goodbye!
-
    
-
    修改实例方法
    
+// Goodbye!
+// Goodbye!
+// Goodbye!
+
    
+
    修改实例方法（Mutating Instance Methods）
    
 
    通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改self或其属性的方法必须将该实例方法标注为mutating，正如来自原始实现的修改方法一样。
    
 
    下面的例子向Swift的Int类型添加了一个新的名为square的修改方法，来实现一个原始值的平方计算：
    
-
    extension Int{
-    mutating func square(){
+
    extension Int {
+    mutating func square() {
         self = self * self
     }
 }
-var someInt = 3
+var someInt = 3
 someInt.square()
-// someInt is now 9
-
    
-
    下标
    
+// someInt 现在值是 9
+
    
+
    下标（Subscripts）
    
 
    扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型Int添加了一个整型下标。该下标[n]返回十进制数字从右向左数的第n个数字
    
 
      
 
    • 123456789[0]返回9
      • 
 
    • 123456789[1]返回8
      • 
 
    
-
    等等
    
-
    extension Int{
+
    ...等等
    
+
    extension Int {
     subscript(digitIndex: Int) -> Int {
-        var decimalBase = 1
-            for _ in 1...digitIndex{
-                decimalBase *= 10
+        var decimalBase = 1
+            for _ in 1...digitIndex {
+                decimalBase *= 10
             }
-        return (self / decimalBase) % 10
+        return (self / decimalBase) % 10
     }
 }
-746381295[0]
-// returns 5
-746381295[1]
-// returns 9
-746381295[2]
-// returns 2
-746381295[8]
-// returns 7
-
    
-
    如果该Int值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：
    
-
    746381295[9]
-//returns 0, 即等同于：
-0746381295[9]
-
    
-
    嵌套类型
    
+746381295[0]
+// returns 5
+746381295[1]
+// returns 9
+746381295[2]
+// returns 2
+746381295[8]
+// returns 7
+
    如果该Int值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：
    
+
    746381295[9]
+//returns 0, 即等同于：
+0746381295[9]
+
    
+
    嵌套类型（Nested Types）
    
 
    扩展可以向已有的类、结构体和枚举添加新的嵌套类型：
    
-
    extension Character {
+
    extension Character {
     enum Kind {
-        case Vowel, Consonant, Other
+        case Vowel, Consonant, Other
     }
-    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
-        default:
-            return .Other
+    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
+        default:
+            return .Other
         }
     }
 }
-
    
-
    该例子向Character添加了新的嵌套枚举。这个名为Kind的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。
    
+
    该例子向Character添加了新的嵌套枚举。这个名为Kind的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。
    
 
    这个类子还向Character添加了一个新的计算实例属性，即kind，用来返回合适的Kind枚举成员。
    
 
    现在，这个嵌套枚举可以和一个Character值联合使用了：
    
-
    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 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 ")
         }
     }
-    print("\n")
+    print("\n")
 }
-printLetterKinds("Hello")
-// 'Hello' is made up of the following kinds of letters:
-// consonant vowel consonant consonant vowel
-
    
-
    函数printLetterKinds的输入是一个String值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的kind计算属性，并打印出合适的类别描述。所以printLetterKinds就可以用来打印一个完整单词中所有字母的类型，正如上述单词"hello"所展示的。
    
+printLetterKinds("Hello")
+// 'Hello' is made up of the following kinds of letters:
+// consonant vowel consonant consonant vowel
+
    函数printLetterKinds的输入是一个String值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的kind计算属性，并打印出合适的类别描述。所以printLetterKinds就可以用来打印一个完整单词中所有字母的类型，正如上述单词"hello"所展示的。
    
 
    
-
    注意
-由于已知character.kind是Character.Kind型，所以Character.Kind中的所有成员值都可以使用switch语句里的形式简写，比如使用 .Vowel代替Character.Kind.Vowel
    
+
    注意：
    
+
    由于已知character.kind是Character.Kind型，所以Character.Kind中的所有成员值都可以使用switch语句里的形式简写，比如使用 .Vowel代替Character.Kind.Vowel
    
 
    
 
                     
@@ -819,7 +814,7 @@ printLetterKinds("Hello")
         
    
 
         
-        
+        
         
         
         
@@ -855,6 +850,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/21_Protocols.html b/chapter2/21_Protocols.html
index 224cb43d..22062371 100644
--- a/chapter2/21_Protocols.html
+++ b/chapter2/21_Protocols.html
@@ -5,12 +5,12 @@
         
         
         
-        协议 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
    
+    
    
     
    
     
     
@@ -98,7 +98,7 @@
     
     
    
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
    
 
    
 
@@ -119,7 +119,7 @@
         
 
         
  • 
-             Introduction
+             序
         
    • 
         
     
@@ -331,7 +331,7 @@
         
  • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,33 +587,55 @@
 
                 
    
                 
-                    
    
+                    
    
                     
-                        
    协议
    
+                        
    
+
    翻译：geek5nan
    
+
    校对：dabing1022
    
+
    
+
    协议
    
 
    
-
    Protocol(协议)用于统一方法和属性的名称,而不实现任何功能,(译者注: 协议在其他语言中也称作接口(Interface)).协议能够被类,枚举,结构体实现,满足协议要求的类,枚举,结构体被称为协议的遵循者.
    
-
    遵循者需要提供协议指定的成员,如属性,方法,操作符,下标等.
    
+
    本页包含内容：
    
+
+
    Protocol(协议)用于统一方法和属性的名称，而不实现任何功能。协议能够被类，枚举，结构体实现，满足协议要求的类，枚举，结构体被称为协议的遵循者。
    
+
    遵循者需要提供协议指定的成员，如属性，方法，操作符，下标等。
    
+
    
 
    协议的语法
    
-
    协议的定义与类,结构体,枚举的定义非常相似,如下所示:
    
+
    协议的定义与类，结构体，枚举的定义非常相似，如下所示：
    
 
    protocol SomeProtocol {
     // 协议内容
 }
-
    在类,结构体,枚举的名称后加上协议名称,中间以冒号:分隔即可实现协议;实现多个协议时,各协议之间用逗号,分隔,如下所示:
    
+

    • 在类，结构体，枚举的名称后加上协议名称，中间以冒号:分隔即可实现协议；实现多个协议时，各协议之间用逗号,分隔，如下所示：

    struct SomeStructure: FirstProtocol, AnotherProtocol {
     // 结构体内容
 }
-

    当某个类含有父类的同时并实现了协议,应当把父类放在所有的协议之前,如下所示:

    +

    当某个类含有父类的同时并实现了协议，应当把父类放在所有的协议之前，如下所示：

    class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
     // 类的内容
 }
-

    属性要求

    -

    协议能够要求其遵循者必须含有一些特定名称和类型的实例属性(instance property)或类属性 (type property),也能够要求属性的(设置权限)settable 和(访问权限)gettable,但它不要求属性是存储型属性(stored property)还是计算型属性(calculate property).

    -

    通常前置var关键字将属性声明为变量.在属性声明后写上{ get set }表示属性为可读写的.{ get }用来表示属性为可读的.即使你为可读的属性实现了setter方法,它也不会出错.

    +

    +

    属性要求

    +

    协议能够要求其遵循者必须含有一些特定名称和类型的实例属性(instance property)或类属性 (type property)，也能够要求属性的(设置权限)settable 和(访问权限)gettable，但它不要求属性是存储型属性(stored property)还是计算型属性(calculate property)。

    +

    通常前置var关键字将属性声明为变量。在属性声明后写上{ get set }表示属性为可读写的。{ get }用来表示属性为可读的。即使你为可读的属性实现了setter方法，它也不会出错。

    protocol SomeProtocol {
     var musBeSettable : Int { get set }
     var doesNotNeedToBeSettable: Int { get }
 }
-

    用类来实现协议时,使用class关键字来表示该属性为类成员;用结构体或枚举实现协议时,则使用static关键字来表示:

    +

    用类来实现协议时，使用class关键字来表示该属性为类成员；用结构体或枚举实现协议时，则使用static关键字来表示：

    protocol AnotherProtocol {
     class var someTypeProperty: Int { get set }
 }
@@ -621,14 +643,14 @@
 protocol FullyNamed {
     var fullName: String { get }
 }
-

    FullyNamed协议含有fullName属性.因此其遵循者必须含有一个名为fullName,类型为String的可读属性.

    +

    FullyNamed协议含有fullName属性。因此其遵循者必须含有一个名为fullName，类型为String的可读属性。

    struct Person: FullyNamed{
     var fullName: String
 }
 let john = Person(fullName: "John Appleseed")
 //john.fullName 为 "John Appleseed"
-

    Person结构体含有一个名为fullName的存储型属性,完整的遵循了协议.(若协议未被完整遵循,编译时则会报错).

    -

    如下所示,Startship类遵循了FullyNamed协议:

    +

    Person结构体含有一个名为fullName的存储型属性，完整的遵循了协议。(若协议未被完整遵循，编译时则会报错)。

    +

    如下所示，Startship类遵循了FullyNamed协议：

    class Starship: FullyNamed {
     var prefix: String?
     var name: String
@@ -642,13 +664,15 @@ let john = Person(fullName: "John Appleseed")
 }
 var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
 // ncc1701.fullName == "USS Enterprise"
-

    Starship类将fullName实现为可读的计算型属性.它的每一个实例都有一个名为name的必备属性和一个名为prefix的可选属性. 当prefix存在时,将prefix插入到name之前来为Starship构建fullName

    +

    Starship类将fullName实现为可读的计算型属性。它的每一个实例都有一个名为name的必备属性和一个名为prefix的可选属性。 当prefix存在时，将prefix插入到name之前来为Starship构建fullName。

    +

    方法要求

    -

    协议能够要求其遵循者必备某些特定的实例方法和类方法.协议方法的声明与普通方法声明相似,但它不需要方法内容.

    +

    协议能够要求其遵循者必备某些特定的实例方法和类方法。协议方法的声明与普通方法声明相似，但它不需要方法内容。

    -

    笔记: 协议方法支持变长参数(variadic parameter),不支持默认参数(default parameter).

    +

    注意：

    +

    协议方法支持变长参数(variadic parameter)，不支持默认参数(default parameter)。

    -

    前置class关键字表示协议中的成员为类成员;当协议用于被枚举或结构体遵循时,则使用static关键字. 如下所示:

    +

    前置class关键字表示协议中的成员为类成员；当协议用于被枚举或结构体遵循时，则使用static关键字。如下所示：

    protocol SomeProtocol {
     class func someTypeMethod()
 }
@@ -656,8 +680,8 @@ var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
 protocol RandomNumberGenerator {
     func random() -> Double
 }
-

    RandomNumberGenerator协议要求其遵循者必须拥有一个名为random, 返回值类型为Double的实例方法. (我们假设随机数在[0,1]区间内).

    -

    LinearCongruentialGenerator类遵循了RandomNumberGenerator协议,并提供了一个叫做线性同余生成器(linear congruential generator)的伪随机数算法.

    +

    RandomNumberGenerator协议要求其遵循者必须拥有一个名为random， 返回值类型为Double的实例方法。(我们假设随机数在[0，1]区间内)。

    +

    LinearCongruentialGenerator类遵循了RandomNumberGenerator协议，并提供了一个叫做线性同余生成器(linear congruential generator)的伪随机数算法。

    class LinearCongruentialGenerator: RandomNumberGenerator {
     var lastRandom = 42.0
     let m = 139968.0
@@ -673,18 +697,20 @@ println("Here's a random number: \(generator.random())")
 // 输出 : "Here's a random number: 0.37464991998171"
 println("And another one: \(generator.random())")
 // 输出 : "And another one: 0.729023776863283"
-

    突变方法要求

    -

    能在方法或函数内部改变实例类型的方法称为突变方法.在值类型(Value Type)(译者注:特指结构体和枚举)中的的函数前缀加上mutating关键字来表示该函数允许改变该实例和其属性的类型. 这一变换过程在Modifyting Value Types from Within Instance Methods章节中有详细描述.

    -

    (译者注:类中的成员为引用类型(Reference Type),可以方便的修改实例及其属性的值而无需改变类型;而结构体和枚举中的成员均为值类型(Value Type),修改变量的值就相当于修改变量的类型,而Swift默认不允许修改类型,因此需要前置mutating关键字用来表示该函数中能够修改类型)

    +

    +

    突变方法要求

    +

    能在方法或函数内部改变实例类型的方法称为突变方法。在值类型(Value Type)(译者注：特指结构体和枚举)中的的函数前缀加上mutating关键字来表示该函数允许改变该实例和其属性的类型。 这一变换过程在实例方法(Instance Methods)章节中有详细描述。

    +

    (译者注：类中的成员为引用类型(Reference Type)，可以方便的修改实例及其属性的值而无需改变类型；而结构体和枚举中的成员均为值类型(Value Type)，修改变量的值就相当于修改变量的类型，而Swift默认不允许修改类型，因此需要前置mutating关键字用来表示该函数中能够修改类型)

    -

    注意: 用类实现协议中的mutating方法时,不用写mutating关键字;用结构体,枚举实现协议中的mutating方法时,必须写mutating关键字.

    +

    注意：

    +

    用class实现协议中的mutating方法时，不用写mutating关键字；用结构体，枚举实现协议中的mutating方法时，必须写mutating关键字。

    -

    如下所示,Togglable协议含有toggle函数.根据函数名称推测,toggle可能用于切换或恢复某个属性的状态.mutating关键字表示它为突变方法:

    +

    如下所示，Togglable协议含有toggle函数。根据函数名称推测，toggle可能用于切换或恢复某个属性的状态。mutating关键字表示它为突变方法：

    protocol Togglable {
     mutating func toggle()
 }
-

    当使用枚举或结构体来实现Togglabl协议时,必须在toggle方法前加上mutating关键字.

    -

    如下所示,OnOffSwitch枚举遵循了Togglable协议,On,Off两个成员用于表示当前状态

    +

    当使用枚举或结构体来实现Togglabl协议时，必须在toggle方法前加上mutating关键字。

    +

    如下所示，OnOffSwitch枚举遵循了Togglable协议，On，Off两个成员用于表示当前状态

    enum OnOffSwitch: Togglable {
     case Off, On
     mutating func toggle() {
@@ -699,16 +725,18 @@ println("And another one: \(generator.random())")
 var lightSwitch = OnOffSwitch.Off
 lightSwitch.toggle()
 //lightSwitch 现在的值为 .On
-

    协议类型

    -

    协议本身不实现任何功能,但你可以将它当做类型来使用.

    -

    使用场景:

    +

    +

    协议类型

    +

    协议本身不实现任何功能，但你可以将它当做类型来使用。

    +

    使用场景：

      -
    • 作为函数,方法或构造器中的参数类型,返回值类型
      • -
    • 作为常量,变量,属性的类型
      • -
    • 作为数组,字典或其他容器中的元素类型
      • +
    • 作为函数，方法或构造器中的参数类型，返回值类型
      • +
    • 作为常量，变量，属性的类型
      • +
    • 作为数组，字典或其他容器中的元素类型
    -

    注意: 协议类型应与其他类型(Int,Double,String)的写法相同,使用驼峰式

    +

    注意：

    +

    协议类型应与其他类型(Int，Double，String)的写法相同，使用驼峰式

    class Dice {
     let sides: Int
@@ -721,11 +749,11 @@ lightSwitch.toggle()
         return Int(generator.random() * Double(sides)) +1
     }
 }
-

    这里定义了一个名为 Dice的类,用来代表桌游中的N个面的骰子.

    -

    Dice含有sides和generator两个属性,前者用来表示骰子有几个面,后者为骰子提供一个随机数生成器.由于后者为RandomNumberGenerator的协议类型.所以它能够被赋值为任意遵循该协议的类型.

    -

    此外,使用构造器(init)来代替之前版本中的setup操作.构造器中含有一个名为generator,类型为RandomNumberGenerator的形参,使得它可以接收任意遵循RandomNumberGenerator协议的类型.

    -

    roll方法用来模拟骰子的面值.它先使用generator的random方法来创建一个[0-1]区间内的随机数种子,然后加工这个随机数种子生成骰子的面值.

    -

    如下所示,LinearCongruentialGenerator的实例作为随机数生成器传入Dice的构造器

    +

    这里定义了一个名为 Dice的类，用来代表桌游中的N个面的骰子。

    +

    Dice含有sides和generator两个属性，前者用来表示骰子有几个面，后者为骰子提供一个随机数生成器。由于后者为RandomNumberGenerator的协议类型。所以它能够被赋值为任意遵循该协议的类型。

    +

    此外，使用构造器(init)来代替之前版本中的setup操作。构造器中含有一个名为generator，类型为RandomNumberGenerator的形参，使得它可以接收任意遵循RandomNumberGenerator协议的类型。

    +

    roll方法用来模拟骰子的面值。它先使用generator的random方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。

    +

    如下所示，LinearCongruentialGenerator的实例作为随机数生成器传入Dice的构造器

    var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
 for _ in 1...5 {
     println("Random dice roll is \(d6.roll())")
@@ -736,11 +764,12 @@ for _ in 1...5 {
 //Random dice roll is 4
 //Random dice roll is 5
 //Random dice roll is 4
-

    委托(代理)模式

    -

    委托是一种设计模式(译者注: 想起了那年 UITableViewDelegate 中的奔跑,那是我逝去的Objective-C...),它允许类或结构体将一些需要它们负责的功能交由(委托)给其他的类型.

    -

    委托模式的实现很简单: 定义协议来封装那些需要被委托的函数和方法, 使其遵循者拥有这些被委托的函数和方法.

    -

    委托模式可以用来响应特定的动作或接收外部数据源提供的数据,而无需要知道外部数据源的类型.

    -

    下文是两个基于骰子游戏的协议:

    +

    +

    委托(代理)模式

    +

    委托是一种设计模式，它允许类或结构体将一些需要它们负责的功能交由(委托)给其他的类型。

    +

    委托模式的实现很简单： 定义协议来封装那些需要被委托的函数和方法， 使其遵循者拥有这些被委托的函数和方法。

    +

    委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型。

    +

    下文是两个基于骰子游戏的协议：

    protocol DiceGame {
     var dice: Dice { get }
     func play()
@@ -750,8 +779,8 @@ protocol DiceGameDelegate {
     func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int)
     func gameDidEnd(game: DiceGame)
 }
-

    DiceGame协议可以在任意含有骰子的游戏中实现,DiceGameDelegate协议可以用来追踪DiceGame的游戏过程

    -

    如下所示,SnakesAndLadders是Snakes and Ladders(译者注:Control Flow章节有该游戏的详细介绍)游戏的新版本.新版本使用Dice作为骰子,并且实现了DiceGame和DiceGameDelegate协议

    +

    DiceGame协议可以在任意含有骰子的游戏中实现，DiceGameDelegate协议可以用来追踪DiceGame的游戏过程。

    +

    如下所示，SnakesAndLadders是Snakes and Ladders(译者注：控制流章节有该游戏的详细介绍)游戏的新版本。新版本使用Dice作为骰子，并且实现了DiceGame和DiceGameDelegate协议

    class SnakesAndLadders: DiceGame {
     let finalSquare = 25
     let dic = Dice(sides: 6, generator: LinearCongruentialGenerator())
@@ -782,13 +811,14 @@ protocol DiceGameDelegate {
          delegate?.gameDIdEnd(self)
      }
 }
-

    游戏的初始化设置(setup)被为SnakesAndLadders类的构造器(initializer)实现.所有的游戏逻辑被转移到了play方法中.

    +

    游戏的初始化设置(setup)被SnakesAndLadders类的构造器(initializer)实现。所有的游戏逻辑被转移到了play方法中。

    -

    注意:因为delegate并不是该游戏的必备条件,delegate被定义为遵循DiceGameDelegate协议的可选属性

    +

    注意：

    +

    因为delegate并不是该游戏的必备条件，delegate被定义为遵循DiceGameDelegate协议的可选属性

    -

    DicegameDelegate协议提供了三个方法用来追踪游戏过程.被放置于游戏的逻辑中,即play()方法内.分别在游戏开始时,新一轮开始时,游戏结束时被调用.

    -

    因为delegate是一个遵循DiceGameDelegate的可选属性,因此在play()方法中使用了可选链来调用委托方法. 若delegate属性为nil, 则委托调用优雅地失效.若delegate不为nil,则委托方法被调用

    -

    如下所示,DiceGameTracker遵循了DiceGameDelegate协议

    +

    DicegameDelegate协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即play()方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。

    +

    因为delegate是一个遵循DiceGameDelegate的可选属性，因此在play()方法中使用了可选链来调用委托方法。 若delegate属性为nil， 则委托调用优雅地失效。若delegate不为nil，则委托方法被调用

    +

    如下所示，DiceGameTracker遵循了DiceGameDelegate协议

    class DiceGameTracker: DiceGameDelegate {
     var numberOfTurns = 0
     func gameDidStart(game: DiceGame) {
@@ -806,9 +836,9 @@ protocol DiceGameDelegate {
         println("The game lasted for \(numberOfTurns) turns")
     }
 }
-

    DiceGameTracker实现了DiceGameDelegate协议的方法要求,用来记录游戏已经进行的轮数. 当游戏开始时,numberOfTurns属性被赋值为0; 在每新一轮中递加; 游戏结束后,输出打印游戏的总轮数.

    -

    gameDidStart方法从game参数获取游戏信息并输出.game在方法中被当做DiceGame类型而不是SnakeAndLadders类型,所以方法中只能访问DiceGame协议中的成员.

    -

    DiceGameTracker的运行情况,如下所示:

    +

    DiceGameTracker实现了DiceGameDelegate协议的方法要求，用来记录游戏已经进行的轮数。 当游戏开始时，numberOfTurns属性被赋值为0；在每新一轮中递加；游戏结束后，输出打印游戏的总轮数。

    +

    gameDidStart方法从game参数获取游戏信息并输出。game在方法中被当做DiceGame类型而不是SnakeAndLadders类型，所以方法中只能访问DiceGame协议中的成员。

    +

    DiceGameTracker的运行情况，如下所示：

    “let tracker = DiceGameTracker()
 let game = SnakesAndLadders()
 game.delegate = tracker
@@ -820,12 +850,14 @@ game.play()
 // Rolled a 4
 // Rolled a 5
 // The game lasted for 4 turns”
-

    在扩展中添加协议成员

    -

    即便无法修改源代码,依然可以通过扩展(Extension)来扩充已存在类型(译者注: 类,结构体,枚举等).扩展可以为已存在的类型添加属性,方法,下标,协议等成员.详情请在扩展章节中查看.

    +

    +

    在扩展中添加协议成员

    +

    即便无法修改源代码，依然可以通过扩展(Extension)来扩充已存在类型(译者注： 类，结构体，枚举等)。扩展可以为已存在的类型添加属性，方法，下标，协议等成员。详情请在扩展章节中查看。

    -

    注意: 通过扩展为已存在的类型遵循协议时,该类型的所有实例也会随之添加协议中的方法

    +

    注意：

    +

    通过扩展为已存在的类型遵循协议时，该类型的所有实例也会随之添加协议中的方法

    -

    TextRepresentable协议含有一个asText,如下所示:

    +

    TextRepresentable协议含有一个asText，如下所示：

    protocol TextRepresentable {
     func asText() -> String
 }
@@ -835,11 +867,11 @@ game.play()
         return "A \(sides)-sided dice"
     }
 }
-

    从现在起,Dice类型的实例可被当作TextRepresentable类型:

    +

    从现在起，Dice类型的实例可被当作TextRepresentable类型：

    let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
 println(d12.asText())
 // 输出 "A 12-sided dice"
-

    SnakesAndLadders类也可以通过扩展的方式来遵循协议:

    +

    SnakesAndLadders类也可以通过扩展的方式来遵循协议：

    extension SnakeAndLadders: TextRepresentable {
     func asText() -> String {
         return "A game of Snakes and Ladders with \(finalSquare) squares"
@@ -847,8 +879,9 @@ println(d12.asText())
 }
 println(game.asText())
 // 输出 "A game of Snakes and Ladders with 25 squares"
-

    通过延展补充协议声明

    -

    当一个类型已经实现了协议中的所有要求,却没有声明时,可以通过扩展来补充协议声明:

    +

    +

    通过延展补充协议声明

    +

    当一个类型已经实现了协议中的所有要求，却没有声明时，可以通过扩展来补充协议声明：

    struct Hamster {
     var name: String
     func asText() -> String {
@@ -856,36 +889,39 @@ println(game.asText())
     }
 }
 extension Hamster: TextRepresentabl {}
-

    从现在起,Hamster的实例可以作为TextRepresentable类型使用

    +

    从现在起，Hamster的实例可以作为TextRepresentable类型使用

    let simonTheHamster = Hamster(name: "Simon")
 let somethingTextRepresentable: TextRepresentabl = simonTheHamester
 println(somethingTextRepresentable.asText())
 // 输出 "A hamster named Simon"
    -

    注意: 即时满足了协议的所有要求,类型也不会自动转变,因此你必须为它做出明显的协议声明

    +

    注意：

    +

    即时满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明

    +

    集合中的协议类型

    -

    协议类型可以被集合使用,表示集合中的元素均为协议类型:

    +

    协议类型可以被集合使用，表示集合中的元素均为协议类型：

    let things: TextRepresentable[] = [game,d12,simoTheHamster]
-

    如下所示,things数组可以被直接遍历,并调用其中元素的asText()函数:

    +

    如下所示，things数组可以被直接遍历，并调用其中元素的asText()函数：

    for thing in things {
     println(thing.asText())
 }
 // A game of Snakes and Ladders with 25 squares
 // A 12-sided dice
 // A hamster named Simon
-

    thing被当做是TextRepresentable类型而不是Dice,DiceGame,Hamster等类型.因此能且仅能调用asText方法

    +

    thing被当做是TextRepresentable类型而不是Dice，DiceGame，Hamster等类型。因此能且仅能调用asText方法

    +

    协议的继承

    -

    协议能够继承一到多个其他协议.语法与类的继承相似,多个协议间用逗号,分隔

    +

    协议能够继承一到多个其他协议。语法与类的继承相似，多个协议间用逗号,分隔

    protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
     // 协议定义
 }
-

    如下所示,PrettyTextRepresentable协议继承了TextRepresentable协议

    +

    如下所示，PrettyTextRepresentable协议继承了TextRepresentable协议

    protocol PrettyTextRepresentable: TextRepresentable {
     func asPrettyText() -> String
 }
-

    遵循``PrettyTextRepresentable协议的同时,也需要遵循TextRepresentable`协议.

    -

    如下所示,用扩展为SnakesAndLadders遵循PrettyTextRepresentable协议:

    +

    遵循``PrettyTextRepresentable协议的同时，也需要遵循TextRepresentable`协议。

    +

    如下所示，用扩展为SnakesAndLadders遵循PrettyTextRepresentable协议：

    extension SnakesAndLadders: PrettyTextRepresentable {
     func asPrettyText() -> String {
         var output = asText() + ":\n"
@@ -902,21 +938,22 @@ println(somethingTextRepresentable.asText())
         return output
     }
 }
-

    在for in中迭代出了board数组中的每一个元素:

    +

    在for in中迭代出了board数组中的每一个元素：

      -
    • 当从数组中迭代出的元素的值大于0时,用▲表示
      • -
    • 当从数组中迭代出的元素的值小于0时,用▼表示
      • -
    • 当从数组中迭代出的元素的值等于0时,用○表示
      • +
    • 当从数组中迭代出的元素的值大于0时，用▲表示
      • +
    • 当从数组中迭代出的元素的值小于0时，用▼表示
      • +
    • 当从数组中迭代出的元素的值等于0时，用○表示
    -

    任意SankesAndLadders的实例都可以使用asPrettyText()方法.

    +

    任意SankesAndLadders的实例都可以使用asPrettyText()方法。

    println(game.asPrettyText())
 // A game of Snakes and Ladders with 25 squares:
 // ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
-

    协议合成

    -

    一个协议可由多个协议采用protocol<SomeProtocol, AnotherProtocol>这样的格式进行组合,称为协议合成(protocol composition).

    -

    举个栗子:

    +

    +

    协议合成

    +

    一个协议可由多个协议采用protocol<SomeProtocol, AnotherProtocol>这样的格式进行组合，称为协议合成(protocol composition)。

    +

    举个例子：

    protocol Named {
-var name: String { get }
+    var name: String { get }
 }
 protocol Aged {
     var age: Int { get }
@@ -926,53 +963,55 @@ struct Person: Named, Aged {
     var age: Int
 }
 func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
-println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
+    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
 }
 let birthdayPerson = Person(name: "Malcolm", age: 21)
 wishHappyBirthday(birthdayPerson)
 // 输出 "Happy birthday Malcolm - you're 21!
-

    Named协议包含String类型的name属性;Aged协议包含Int类型的age属性.Person结构体遵循了这两个协议.

    -

    wishHappyBirthday函数的形参celebrator的类型为protocol<Named,Aged>.可以传入任意遵循这两个协议的类型的实例

    +

    Named协议包含String类型的name属性；Aged协议包含Int类型的age属性。Person结构体遵循了这两个协议。

    +

    wishHappyBirthday函数的形参celebrator的类型为protocol<Named,Aged>。可以传入任意遵循这两个协议的类型的实例

    -

    注意: 协议合成并不会生成一个新协议类型,而是将多个协议合成为一个临时的协议,超出范围后立即失效.

    +

    注意：

    +

    协议合成并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。

    +

    检验协议的一致性

    -

    使用is检验协议一致性,使用as将协议类型向下转换(downcast)为的其他协议类型.检验与转换的语法和之前相同(详情查看Typy Casting章节):

    +

    使用is检验协议一致性，使用as将协议类型向下转换(downcast)为的其他协议类型。检验与转换的语法和之前相同(详情查看类型检查)：

      -
    • is操作符用来检查实例是否遵循了某个协议.
      • -
    • as?返回一个可选值,当实例遵循协议时,返回该协议类型;否则返回nil
      • -

    • as用以强制向下转型.

      -

      @objc protocol HasArea {

      -
        var area: Double { get }
-

      }

      -
      • +
    • is操作符用来检查实例是否遵循了某个协议。
      • +
    • as?返回一个可选值，当实例遵循协议时，返回该协议类型；否则返回nil
      • +
    • as用以强制向下转换型。
    -
    -

    注意: @objc用来表示协议是可选的,也可以用来表示暴露给Objective-C的代码,此外,@objc型协议只对类有效,因此只能在类中检查协议的一致性.详情查看Using Siwft with Cocoa and Objectivei-c.

    +
    @objc protocol HasArea {
+    var area: Double { get }
+}
+
    +

    注意：

    +

    @objc用来表示协议是可选的，也可以用来表示暴露给Objective-C的代码，此外，@objc型协议只对类有效，因此只能在类中检查协议的一致性。详情查看Using Siwft with Cocoa and Objectivei-c。

    class Circle: HasArea {
     let pi = 3.1415927
     var radius: Double
-    var area: Double { return pi * radius * radius }
+    var area:≈radius }
     init(radius: Double) { self.radius = radius }
 }
 class Country: HasArea {
     var area: Double
     init(area: Double) { self.area = area }
 }
-

    Circle和Country都遵循了HasArea协议,前者把area写为计算型属性,后者则把area写为存储型属性

    -

    如下所示,Animal类没有实现任何协议

    +

    Circle和Country都遵循了HasArea协议，前者把area写为计算型属性（computed property），后者则把area写为存储型属性（stored property）。

    +

    如下所示，Animal类没有实现任何协议

    class Animal {
     var legs: Int
     init(legs: Int) { self.legs = legs }
 }
-

    Circle,Country,Animal并没有一个相同的基类,所以采用AnyObject类型的数组来装载在他们的实例,如下所示:

    +

    Circle,Country,Animal并没有一个相同的基类，所以采用AnyObject类型的数组来装载在他们的实例，如下所示：

    let objects: AnyObject[] = [
     Circle(radius: 2.0),
     Country(area: 243_610),
     Animal(legs: 4)
 ]
-

    如下所示,在迭代时检查object数组的元素是否遵循了HasArea协议:

    +

    如下所示，在迭代时检查object数组的元素是否遵循了HasArea协议：

    for object in objects {
     if let objectWithArea = object as? HasArea {
         println("Area is \(objectWithArea.area)")
@@ -983,25 +1022,28 @@ class Country: HasArea {
 // Area is 12.5663708
 // Area is 243610.0
 // Something that doesn't have an area
-

    当数组中的元素遵循HasArea协议时,通过as?操作符将其可选绑定(optional binding)到objectWithArea常量上.

    -

    objects数组中元素的类型并不会因为向下转型而改变,当它们被赋值给objectWithArea时只被视为HasArea类型,因此只有area属性能够被访问.

    +

    当数组中的元素遵循HasArea协议时，通过as?操作符将其可选绑定(optional binding)到objectWithArea常量上。

    +

    objects数组中元素的类型并不会因为向下转型而改变，当它们被赋值给objectWithArea时只被视为HasArea类型，因此只有area属性能够被访问。

    +

    可选协议要求

    -

    可选协议含有可选成员,其遵循者可以选择是否实现这些成员.在协议中使用@optional关键字作为前缀来定义可选成员.

    -

    可选协议在调用时使用可选链,详细内容在Optional Chaning章节中查看.

    -

    像someOptionalMethod?(someArgument)一样,你可以在可选方法名称后加上?来检查该方法是否被实现.可选方法和可选属性都会返回一个可选值(optional value),当其不可访问时,?之后语句不会执行,并返回nil

    +

    可选协议含有可选成员，其遵循者可以选择是否实现这些成员。在协议中使用@optional关键字作为前缀来定义可选成员。

    +

    可选协议在调用时使用可选链，详细内容在可选链章节中查看。

    +

    像someOptionalMethod?(someArgument)一样，你可以在可选方法名称后加上?来检查该方法是否被实现。可选方法和可选属性都会返回一个可选值(optional value)，当其不可访问时，?之后语句不会执行，并返回nil。

    -

    注意: 可选协议只能在含有@objc前缀的协议中生效.且@objc的协议只能被类遵循

    +

    注意：

    +

    可选协议只能在含有@objc前缀的协议中生效。且@objc的协议只能被类遵循。

    -

    Counter类使用CounterDataSource类型的外部数据源来提供增量值(increment amount),如下所示:

    +

    Counter类使用CounterDataSource类型的外部数据源来提供增量值(increment amount)，如下所示：

    @objc protocol CounterDataSource {
     @optional func incrementForCount(count: Int) -> Int
     @optional var fixedIncrement: Int { get }
 }
-

    CounterDataSource含有incrementForCount的可选方法和fiexdIncrement的可选属性.

    +

    CounterDataSource含有incrementForCount的可选方法和fiexdIncrement的可选属性。

    -

    注意: CounterDataSource中的属性和方法都是可选的,因此可以在类中声明但不实现这些成员,尽管技术上允许这样做,不过最好不要这样写.

    +

    注意：

    +

    CounterDataSource中的属性和方法都是可选的，因此可以在类中声明但不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。

    -

    Counter类含有CounterDataSource?类型的可选属性dataSource,如下所示:

    +

    Counter类含有CounterDataSource?类型的可选属性dataSource，如下所示：

    @objc class Counter {
     var count = 0
     var dataSource: CounterDataSource?
@@ -1013,19 +1055,19 @@ class Country: HasArea {
         }
     }
 }
-

    count属性用于存储当前的值,increment方法用来为count赋值.

    -

    increment方法通过可选链,尝试从两种可选成员中获取count.

    +

    count属性用于存储当前的值，increment方法用来为count赋值。

    +

    increment方法通过可选链，尝试从两种可选成员中获取count。

      -
    1. 由于dataSource可能为nil,因此在dataSource后边加上了?标记来表明只在dataSource非空时才去调用incrementForCount`方法.
      2. -
    2. 即使dataSource存在,但是也无法保证其是否实现了incrementForCount方法,因此在incrementForCount方法后边也加有?标记
      3. +
    3. 由于dataSource可能为nil，因此在dataSource后边加上了?标记来表明只在dataSource非空时才去调用incrementForCount`方法。
      4. +
    4. 即使dataSource存在，但是也无法保证其是否实现了incrementForCount方法，因此在incrementForCount方法后边也加有?标记。
    -

    在调用incrementForCount方法后,Int型可选值通过可选绑定(optional binding)自动拆包并赋值给常量amount.

    -

    当incrementForCount不能被调用时,尝试使用可选属性``fixedIncrement来代替.

    -

    ThreeSource实现了CounterDataSource协议,如下所示:

    +

    在调用incrementForCount方法后，Int型可选值通过可选绑定(optional binding)自动拆包并赋值给常量amount。

    +

    当incrementForCount不能被调用时，尝试使用可选属性``fixedIncrement来代替。

    +

    ThreeSource实现了CounterDataSource协议，如下所示：

    class ThreeSource: CounterDataSource {
     let fixedIncrement = 3
 }
-

    使用ThreeSource作为数据源开实例化一个Counter:

    +

    使用ThreeSource作为数据源开实例化一个Counter：

    var counter = Counter()
 counter.dataSource = ThreeSource()
 for _ in 1...4 {
@@ -1036,7 +1078,7 @@ for _ in 1...4 {
 // 6
 // 9
 // 12
-

    TowardsZeroSource实现了CounterDataSource协议中的incrementForCount方法,如下所示:

    +

    TowardsZeroSource实现了CounterDataSource协议中的incrementForCount方法，如下所示：

    class TowardsZeroSource: CounterDataSource {
 func incrementForCount(count: Int) -> Int {
         if count == 0 {
@@ -1048,7 +1090,7 @@ func incrementForCount(count: Int) -> Int {
         }
     }
 }
-

    下边是执行的代码:

    +

    下边是执行的代码：

    counter.count = -4
 counter.dataSource = TowardsZeroSource()
 for _ in 1...5 {
@@ -1105,6 +1147,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/22_Generics.html b/chapter2/22_Generics.html
index c47a6893..dfe0c79a 100644
--- a/chapter2/22_Generics.html
+++ b/chapter2/22_Generics.html
@@ -5,12 +5,12 @@
         
         
         
-        泛型 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
    
+    
    
     
    
     
     
@@ -98,7 +98,7 @@
     
     
    
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
    
 
    
 
@@ -119,7 +119,7 @@
         
 
         
  • 
-             Introduction
+             序
         
    • 
         
     
@@ -331,7 +331,7 @@
         
  • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,107 +587,108 @@
 
                 
    
                 
-                    
    
+                    
    
                     
-                        
    泛型
    
+                        
    
+
    翻译：takalard
    
+
    校对：lifedim
    
+
    
+
    泛型
    
 
    
 
    本页包含内容：
    
 
-
    泛型代码可以确保你写出灵活的，可重用的函数和定义出任何你所确定好的需求的类型。你的可以写出避免重复的代码，并且用一种清晰的，抽象的方式表达出来。
    
-
    泛型是Swift需要强大特征中的其中一个，许多Swift标准库是通过泛型代码构建出来的。事实上，你已经使用泛型贯穿着整个Language Guide，即便你没有实现它。例如：Swift的Array和Dictionary类型都是泛型集。你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他Swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(dictionary)，而且这些类型可以是没有限制的。
    
-
    
+
    泛型代码可以让你写出根据自我需求定义、适用于任何类型的，灵活且可重用的函数和类型。它的可以让你避免重复的代码，用一种清晰和抽象的方式来表达代码的意图。
    
+
    泛型是 Swift 强大特征中的其中一个，许多 Swift 标准库是通过泛型代码构建出来的。事实上，泛型的使用贯穿了整本语言手册，只是你没有发现而已。例如，Swift 的数组和字典类型都是泛型集。你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他 Swift 的类型数据数组。同样的，你也可以创建存储任何指定类型的字典（dictionary），而且这些类型可以是没有限制的。
    
+
    
 
    泛型所解决的问题
    
-
    这里是一个标准的，非泛型函数swapTwoInts,用来交换两个Int值：
    
-
        func swapTwoInts(inout a: Int, inout b: Int) 
-        let temporaryA = a
-        a = b
-        b = temporaryA
-    }
-
    
-
    这个函数使用in-out参数交换a和b的值，这两个参数被描述为[In-Out类型参数][1]。
    
-
    swapTwoInts函数可以交换b的原始值到a，也可以交换a的原始值到b，你可以调用这个函数交换两个Int变量值：
    
-
        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"
-
    
-
    swapTwoInts函数是非常有用的，但是它只能交换Int值，如果你想要交换两个String或者Double，就不得不写更多的函数，如 swapTwoStrings和swapTwoDoublesfunctions，如同如下所示：
    
-
        func swapTwoStrings(inout a: String, inout b: String) {
-        let temporaryA = a
-        a = b
-        b = temporaryA
-    }
+
    这里是一个标准的，非泛型函数swapTwoInts,用来交换两个Int值：
    
+
    func swapTwoInts(inout a: Int, inout b: Int)
+    let temporaryA = a
+    a = b
+    b = temporaryA
+}
+
    这个函数使用写入读出（in-out）参数来交换a和b的值，请参考[写入读出参数][1]。
    
+
    swapTwoInts函数可以交换b的原始值到a，也可以交换a的原始值到b，你可以调用这个函数交换两个Int变量值：
    
+
    var someInt = 3
+var anotherInt = 107
+swapTwoInts(&someInt, &anotherInt)
+println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
+// 输出 "someInt is now 107, and anotherInt is now 3"
+
    swapTwoInts函数是非常有用的，但是它只能交换Int值，如果你想要交换两个String或者Double，就不得不写更多的函数，如 swapTwoStrings和swapTwoDoublesfunctions，如同如下所示：
    
+
    func swapTwoStrings(inout a: String, inout b: String) {
+    let temporaryA = a
+    a = b
+    b = temporaryA
+}
 
-    func swapTwoDoubles(inout a: Double, inout b: Double) {
-        let temporaryA = a
-        a = b
-        b = temporaryA
-    }
-
    
-
    你可能注意到 swapTwoInts、 swapTwoStrings和swapTwoDoubles函数主题都是相同的，唯一不同之处就在于传入的变量不同，分别是Int、String和Double。
    
+func swapTwoDoubles(inout a: Double, inout b: Double) {
+    let temporaryA = a
+    a = b
+    b = temporaryA
+}
+
    你可能注意到 swapTwoInts、 swapTwoStrings和swapTwoDoubles函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是Int、String和Double。
    
 
    但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）
    
 
    
-
    NOTE
    
-
    In all three functions, it is important that the types of a and b are defined to be the same as each other. If a and b were not of the same type, it would not be possible to swap their values. Swift is a type-safe language, and does not allow (for example) a variable of type String and a variable of type Double to swap values with each other. Attempting to do so would be reported as a compile-time error.
    
+
    注意：
+在所有三个函数中，a和b的类型是一样的。如果a和b不是相同的类型，那它们俩就不能互换值。Swift 是类型安全的语言，所以它不允许一个String类型的变量和一个Double类型的变量互相交换值。如果一定要做，Swift 将报编译错误。
    
 
    
+
    
 
    泛型函数
    
-
    泛型函数可以工作于任何类型，这里是一个上面swapTwoInts函数的泛型版本，用于交换两个值： 
    
-
        func swapTwoValues<T>(inout a: T, inout b: T) {
-        let temporaryA = a
-        a = b
-        b = temporaryA
-    }
-
    
-
    swapTwoValues函数主体和swapTwoInts函数是一样，而且，只在第一行稍微有那么一点点不同于swapTwoInts，如下所示：
    
-
        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)是用尖括号括起来的()。这个尖括号告诉Swift那个T是swapTwoValues函数所定义的一个节点类型。因为T是一个节点，Swift不会去查找每一个命名为T的实际类型。
    
-
    swapTwoValues函数除了只要传入的两个任何类型值是同一类型外，也可以作为swapTwoInts函数被调用。每次swapTwoValues被调用，T所代表的类型值都会传给函数。
    
-
    在下面的两个例子中,T分别代表Tnt和String：
    
-
        var someInt = 3
-    var anotherInt = 107
-    swapTwoValues(&someInt, &anotherInt)
-    // someInt is now 107, and anotherInt is now 3
+
    泛型函数可以工作于任何类型，这里是一个上面swapTwoInts函数的泛型版本，用于交换两个值：
    
+
    func swapTwoValues<T>(inout a: T, inout b: T) {
+    let temporaryA = a
+    a = b
+    b = temporaryA
+}
+
    swapTwoValues函数主体和swapTwoInts函数是一样的，它只在第一行稍微有那么一点点不同于swapTwoInts，如下所示：
    
+
    func swapTwoInts(inout a: Int, inout b: Int)
+func swapTwoValues<T>(inout a: T, inout b: T)
+
    这个函数的泛型版本使用了占位类型名字（通常此情况下用字母T来表示）来代替实际类型名（如In、String或Doubl）。占位类型名没有提示T必须是什么类型，但是它提示了a和b必须是同一类型T，而不管T表示什么类型。只有swapTwoValues函数在每次调用时所传入的实际类型才能决定T所代表的类型。
    
+
    另外一个不同之处在于这个泛型函数名后面跟着的展位类型名字（T）是用尖括号括起来的（）。这个尖括号告诉 Swift 那个T是swapTwoValues函数所定义的一个类型。因为T是一个占位命名类型，Swift 不会去查找命名为T的实际类型。
    
+
    swapTwoValues函数除了要求传入的两个任何类型值是同一类型外，也可以作为swapTwoInts函数被调用。每次swapTwoValues被调用，T所代表的类型值都会传给函数。
    
+
    在下面的两个例子中,T分别代表Int和String：
    
+
    var someInt = 3
+var anotherInt = 107
+swapTwoValues(&someInt, &anotherInt)
+// someInt is now 107, and anotherInt is now 3
 
-    var someString = "hello"
-    var anotherString = "world"
-    swapTwoValues(&someString, &anotherString)
-    // someString is now "world", and anotherString is now "hello"
-
    
-
    
-
    NOTE
    
-
    The swapTwoValues function defined above is inspired by a generic function called swap, which is part of the Swift standard library, and is automatically made available for you to use in your apps. If you need the behavior of the swapTwoValues function in your own code, you can use Swift’s existing swap function rather than providing your own implementation.
    
+var someString = "hello"
+var anotherString = "world"
+swapTwoValues(&someString, &anotherString)
+// someString is now "world", and anotherString is now "hello"
+
    
+
    注意
+上面定义的函数swapTwoValues是受swap函数启发而实现的。swap函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似swapTwoValues函数的功能，你可以使用已存在的交换函数swap函数。
    
 
    
-
    Type Parameters
    
+
    
 
    类型参数
    
-
    在上面的swapTwoValues例子中，节点类型T是一种类型参数的示例。类型参数指定并命名为一个节点类型，并且紧随在函数名后面，并用一对尖括号括起来（如）。
    
-
    一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如swapTwoValues函数中的参数a和b），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的节点类型不管函数任何时候被调用，都会被实际类型所替换（在上面swapTwoValues例子中，当函数第一次被调用时，T被Int替换，第二次调用时，被String替换。）。
    
+
    在上面的swapTwoValues例子中，占位类型T是一种类型参数的示例。类型参数指定并命名为一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（如）。
    
+
    一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如swapTwoValues函数中的参数a和b），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的占位类型不管函数任何时候被调用，都会被实际类型所替换（在上面swapTwoValues例子中，当函数第一次被调用时，T被Int替换，第二次调用时，被String替换。）。
    
 
    你可支持多个类型参数，命名在尖括号中，用逗号分开。
    
+
    
 
    命名类型参数
    
-
    在简单的情况下，泛型函数或泛型类型需要指定一个节点类型（如上面的swapTwoValues泛型函数，或一个存储单一类型的泛型集，如Array），通常用一单个字母T来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
    
-
    如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift字典(Dictionary)类型有两个类型参数，一个是key，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为KeyType和ValueType，用来记住它们在你的泛型代码中的作用。
    
+
    在简单的情况下，泛型函数或泛型类型需要指定一个占位类型（如上面的swapTwoValues泛型函数，或一个存储单一类型的泛型集，如数组），通常用一单个字母T来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
    
+
    如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为KeyType和ValueType，用来记住它们在你的泛型代码中的作用。
    
 
    
-
    NOTE
    
-
    Always give type parameters UpperCamelCase names (such as T and KeyType) to indicate that they are a placeholder for a type, not a value.
    
+
    注意
+请始终使用大写字母开头的驼峰式命名法（例如T和KeyType）来给类型参数命名，以表明它们是类型的占位符，而非类型值。
    
 
    
+
    
 
    泛型类型
    
-
    通常在泛型函数中，Swift允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同Array和Dictionary的用法。
    
-
    这部分向你展示如何写一个泛型集类型-Stack(栈)。一个栈是一系列值域的集合，和array(数组)相似，但其是一个比Swift的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop一个值出栈）。
    
+
    通常在泛型函数中，Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同Array和Dictionary的用法。
    
+
    这部分向你展示如何写一个泛型集类型--Stack（栈）。一个栈是一系列值域的集合，和Array（数组）类似，但其是一个比 Swift 的Array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop一个值出栈）。
    
 
    
-
    NOTE
    
-
    The concept of a stack is used by the UINavigationController class to model the view controllers in its navigation hierarchy. You call the UINavigationController class pushViewController:animated: method to add (or push) a view controller on to the navigation stack, and its popViewControllerAnimated: method to remove (or pop) a view controller from the navigation stack. A stack is a useful collection model whenever you need a strict “last in, first out” approach to managing a collection.
    
+
    注意
+栈的概念已被UINavigationController类使用来模拟试图控制器的导航结构。你通过调用UINavigationController的pushViewController:animated:方法来为导航栈添加（add）新的试图控制器；而通过popViewControllerAnimated:的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的后进先出方式来管理集合，堆栈都是最实用的模型。
    
 
    
 
    下图展示了一个栈的压栈(push)/出栈(pop)的行为：
    
 
    ![此处输入图片的描述][2]
    
@@ -699,125 +700,116 @@
 
  • 移除掉一个值后，现在栈又重新只有三个值。
    • 
 
 
    这里展示了如何写一个非泛型版本的栈，Int值型的栈：
    
-
    struct IntStack {
+
    struct IntStack {
     var items = Int[]()
     mutating func push(item: Int) {
         items.append(item)
     }
     mutating func pop() -> Int {
-        return items.removeLast()
+        return items.removeLast()
     }
 }
-
    
-
    这个结构体在栈中使用一个Array性质的items存储值。Stack提供两个方法：push和pop，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为他们需要修改（或转换）结构体的items数组。
    
+
    这个结构体在栈中使用一个Array性质的items存储值。Stack提供两个方法：push和pop，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为他们需要修改（或转换）结构体的items数组。
    
 
    上面所展现的IntStack类型只能用于Int值，不过，其对于定义一个泛型Stack类（可以处理任何类型值的栈）是非常有用的。
    
 
    这里是一个相同代码的泛型版本：
    
-
    struct Stack<T> {
+
    struct Stack<T> {
     var items = T[]()
     mutating func push(item: T) {
         items.append(item)
     }
     mutating func pop() -> T {
-        return items.removeLast()
+        return items.removeLast()
     }
 }
-
    
-
    注意到Stack的泛型版本基本上和非泛型版本相同，但是泛型版本的节点类型参数为T代替了实际Int类型。这种类型参数包含在一对尖括号里(<T>)，紧随在结构体名字后面。
    
-
    T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，T在如下三个地方被用作节点：
    
+
    注意到Stack的泛型版本基本上和非泛型版本相同，但是泛型版本的占位类型参数为T代替了实际Int类型。这种类型参数包含在一对尖括号里（<T>），紧随在结构体名字后面。
    
+
    T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，T在如下三个地方被用作节点：
    
 
      
 
    • 创建一个名为items的属性，使用空的T类型值数组对其进行初始化；
      • 
 
    • 指定一个包含一个参数名为item的push方法，该参数必须是T类型；
      • 
 
    • 指定一个pop方法的返回值，该返回值将是一个T类型值。
      • 
 
    
 
    当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个Stack实例，同创建Array和Dictionary一样：
    
-
    var stackOfStrings = Stack<String>()
-stackOfStrings.push("uno")
-stackOfStrings.push("dos")
-stackOfStrings.push("tres")
-stackOfStrings.push("cuatro")
-// 现在栈已经有4个string了
-
    
-
    下图将展示stackOfStrings如何push这四个值进栈的过程：
    
+
    var stackOfStrings = Stack<String>()
+stackOfStrings.push("uno")
+stackOfStrings.push("dos")
+stackOfStrings.push("tres")
+stackOfStrings.push("cuatro")
+// 现在栈已经有4个string了
+
    下图将展示stackOfStrings如何push这四个值进栈的过程：
    
 
    ![此处输入图片的描述][3]
    
-
    从栈中pop并移除值"cuatro"：
    
-
    let fromTheTop = stackOfStrings.pop()
-// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
-
    
-
    下图展示了如何从栈中pop一个值的过程：
+
    从栈中pop并移除值"cuatro"：
    
+
    let fromTheTop = stackOfStrings.pop()
+// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
+
    下图展示了如何从栈中pop一个值的过程：
 ![此处输入图片的描述][4]
    
-
    由于Stack是泛型类型，所以在Swift中其可以用来创建任何有效类型的栈，这种方式如同Array和Dictionary。
    
+
    由于Stack是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同Array和Dictionary。
    
+
    
 
    类型约束
    
 
    swapTwoValues函数和Stack类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
    
-
    例如，Swift的Dictionary类型对作用于其keys的类型做了些限制。在[Dictionaries][5]的描述中，字典的keys类型必须是hashable，也就是说，必须有一种方法可以使其是唯一的表示。Dictionary之所以需要其keys是hashable是为了以便于其检查其是否包含某个特定key的值。如无此需求，Dictionary即不会告诉是否插入或者替换了某个特定key的值，也不能查找到已经存储在字典里面的给定key值。
    
-
    这个需求强制加上一个类型约束作用于Dictionary的key上，当然其key类型必须遵循Hashable协议（Swift标准库中定义的一个特定协议）。所有的Swift基本类型（如String，Int， Double和 Bool）默认都是hashable。
    
-
    当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如Hashtable具有的类型特征是根据他们概念特征来界定的，而不是他们的直接类型特征。
    
+
    例如，Swift 的Dictionary类型对作用于其键的类型做了些限制。在[字典][5]的描述中，字典的键类型必须是可哈希，也就是说，必须有一种方法可以使其是唯一的表示。Dictionary之所以需要其键是可哈希是为了以便于其检查其是否包含某个特定键的值。如无此需求，Dictionary即不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
    
+
    这个需求强制加上一个类型约束作用于Dictionary的键上，当然其键类型必须遵循Hashable协议（Swift 标准库中定义的一个特定协议）。所有的 Swift 基本类型（如String，Int， Double和 Bool）默认都是可哈希。
    
+
    当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如可哈希具有的类型特征是根据他们概念特征来界定的，而不是他们的直接类型特征。
    
 
    类型约束语法
    
 
    你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：
    
-
    func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
-    // function body goes here
+
    func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
+    // function body goes here
 }
-
    
-
    上面这个假定函数有两个类型参数。第一个类型参数T，有一个需要T必须是SomeClass子类的类型约束；第二个类型参数U，有一个需要U必须遵循SomeProtocol协议的类型约束。
    
+
    上面这个假定函数有两个类型参数。第一个类型参数T，有一个需要T必须是SomeClass子类的类型约束；第二个类型参数U，有一个需要U必须遵循SomeProtocol协议的类型约束。
    
 
    类型约束行为
    
 
    这里有个名为findStringIndex的非泛型函数，该函数功能是去查找包含一给定String值的数组。若查找到匹配的字符串，findStringIndex函数返回该字符串在数组中的索引值（Int），反之则返回nil：
    
-
    func findStringIndex(array: String[], valueToFind: String) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
+
    func findStringIndex(array: String[], valueToFind: String) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
         }
     }
-    return nil
+    return nil
 }
-
    
-
    findStringIndex函数可以作用于查找一字符串数组中的某个字符串:
    
-
    let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
-if let foundIndex = findStringIndex(strings, "llama") {
-    println("The index of llama is \(foundIndex)")
+
    findStringIndex函数可以作用于查找一字符串数组中的某个字符串:
    
+
    let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
+if let foundIndex = findStringIndex(strings, "llama") {
+    println("The index of llama is \(foundIndex)")
 }
-// prints "The index of llama is 2"
-
    
-
    如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数findIndex，用某个类型T值替换掉提到的字符串。
    
+// 输出 "The index of llama is 2"
+
    如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数findIndex，用某个类型T值替换掉提到的字符串。
    
 
    这里展示如何写一个你或许期望的findStringIndex的泛型版本findIndex。请注意这个函数仍然返回Int，是不是有点迷惑呢，而不是泛型类型?那是因为函数返回的是一个可选的索引数，而不是从数组中得到的一个可选值。需要提醒的是，这个函数不会编译，原因在例子后面会说明：
    
-
    func findIndex<T>(array: T[], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
+
    func findIndex<T>(array: T[], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
         }
     }
-    return nil
+    return nil
 }
-
    
-
    上面所写的函数不会编译。这个问题的位置在等式的检查上，“if value == valueToFind”。不是所有的Swift中的类型都可以用等式符(==)进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么Swift没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型T，当你试图编译这部分代码时估计会出现相应的错误。
    
-
    不过，所有的这些并不会让我们无从下手。Swift标准库中定义了一个Equatable协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。
    
+
    上面所写的函数不会编译。这个问题的位置在等式的检查上，“if value == valueToFind”。不是所有的 Swift 中的类型都可以用等式符（==）进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么 Swift 没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型T，当你试图编译这部分代码时估计会出现相应的错误。
    
+
    不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个Equatable协议，该协议要求任何遵循的类型实现等式符（==）和不等符（!=）对任何两个该类型进行比较。所有的 Swift 标准类型自动支持Equatable协议。
    
 
    任何Equatable类型都可以安全的使用在findIndex函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个Equatable类型约束作为类型参数定义的一部分：
    
-
    func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
+
    func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
+    for (index, value) in enumerate(array) {
+        if value == valueToFind {
+            return index
         }
     }
-    return nil
+    return nil
 }
-
    
-
    findIndex中这个单个类型参数写做：T: Equatable，也就意味着“任何T类型都遵循Equatable协议”。
    
-
    findIndex函数现在则可以成功的编译过，并且作用于任何遵循Equatable的类型，如Double或String:
    
-
    let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
-// doubleIndex is an optional Int with no value, because 9.3 is not in the array
-let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
-// stringIndex is an optional Int containing a value of 2
-
    
+
    findIndex中这个单个类型参数写做：T: Equatable，也就意味着“任何T类型都遵循Equatable协议”。
    
+
    findIndex函数现在则可以成功的编译过，并且作用于任何遵循Equatable的类型，如Double或String:
    
+
    let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
+// doubleIndex is an optional Int with no value, because 9.3 is not in the array
+let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
+// stringIndex is an optional Int containing a value of 2
+
    
 
    关联类型
    
 
    当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名（或别名）。作用于关联类型上实际类型是不需要指定的，直到该协议接受。关联类型被指定为typealias关键字。
    
 
    关联类型行为
    
 
    这里是一个Container协议的例子，定义了一个ItemType关联类型：
    
-
    protocol Container {
+
    protocol Container {
     typealias ItemType
     mutating func append(item: ItemType)
     var count: Int { get }
     subscript(i: Int) -> ItemType { get }
 }
-
    
-
    Container协议定义了三个任何容器必须支持的兼容要求：
    
+
    Container协议定义了三个任何容器必须支持的兼容要求：
    
 
      
 
    • 必须可能通过append方法添加一个新item到容器里；
      • 
 
    • 必须可能通过使用count属性获取容器里items的数量，并返回一个Int值；
      • 
@@ -828,88 +820,85 @@ let stringIndex = findIndex(["Mike", 为了定义这三个条件，Container协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。Container协议需要指定任何通过append方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。
      
 
      为了达到此目的，Container协议声明了一个ItemType的关联类型，写作typealias ItemType。The protocol does not define what ItemType is an alias for—that information is left for any conforming type to provide（这个协议不会定义ItemType是遵循类型所提供的何种信息的别名）。尽管如此，ItemType别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在append方法和下标中的类型，以便保证任何期望的Container的行为是强制性的。
      
 
      这里是一个早前IntStack类型的非泛型版本，适用于遵循Container协议：
      
-
      struct IntStack: Container {
-    // original IntStack implementation
+
      struct IntStack: Container {
+    // original IntStack implementation
     var items = Int[]()
     mutating func push(item: Int) {
         items.append(item)
     }
     mutating func pop() -> Int {
-        return items.removeLast()
+        return items.removeLast()
     }
-    // conformance to the Container protocol
+    // conformance to the Container protocol
     typealias ItemType = Int
     mutating func append(item: Int) {
         self.push(item)
     }
     var count: Int {
-    return items.count
+    return items.count
     }
     subscript(i: Int) -> Int {
-        return items[i]
+        return items[i]
     }
 }
-
      
-
      IntStack类型实现了Container协议的所有三个要求，在IntStack类型的每个包含部分的功能都满足这些要求。
      
+
      IntStack类型实现了Container协议的所有三个要求，在IntStack类型的每个包含部分的功能都满足这些要求。
      
 
      此外，IntStack指定了Container的实现，适用的ItemType被用作Int类型。对于这个Container协议实现而言，定义 typealias ItemType = Int，将抽象的ItemType类型转换为具体的Int类型。
      
 
      感谢Swift类型参考，你不用在IntStack定义部分声明一个具体的Int的ItemType。由于IntStack遵循Container协议的所有要求，只要通过简单的查找append方法的item参数类型和下标返回的类型，Swift就可以推断出合适的ItemType来使用。确实，如果上面的代码中你删除了 typealias ItemType = Int这一行，一切仍旧可以工作，因为它清楚的知道ItemType使用的是何种类型。
      
 
      你也可以生成遵循Container协议的泛型Stack类型：
      
-
      struct Stack<T>: Container {
-    // original Stack<T> implementation
+
      struct Stack<T>: Container {
+    // original Stack<T> implementation
     var items = T[]()
     mutating func push(item: T) {
         items.append(item)
     }
     mutating func pop() -> T {
-        return items.removeLast()
+        return items.removeLast()
     }
-    // conformance to the Container protocol
+    // conformance to the Container protocol
     mutating func append(item: T) {
         self.push(item)
     }
     var count: Int {
-    return items.count
+    return items.count
     }
     subscript(i: Int) -> T {
-        return items[i]
+        return items[i]
     }
 }
-
      
-
      这个时候，节点类型参数T被用作append方法的item参数和下标的返回类型。Swift因此可以推断出被用作这个特定容器的ItemType的T的合适类型。
      
+
      这个时候，占位类型参数T被用作append方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的ItemType的T的合适类型。
      
 
      扩展一个存在的类型为一指定关联类型
      
-
      在[Adding Protocol Conformance with an Extension][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
      
-
      Swift的Array已经提供append方法，一个count属性和通过下标来查找一个自己的元素。这三个功能都达到Container协议的要求。也就意味着你可以扩展Array去遵循Container协议，只要通过简单声明Array适用于该协议而已。如何实践这样一个空扩展，在[Declaring Protocol Adoption with an Extension][7]中有描述这样一个实现一个空扩展的行为：
      
-
      extension Array: Container {}
-
      
-
      如同上面的泛型Stack类型一样，Array的append方法和下标保证Swift可以推断出ItemType所使用的适用的类型。定义了这个扩展后，你可以将任何Array当作Container来使用。
      
+
      在[使用扩展来添加协议兼容性][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
      
+
      Swift的Array已经提供append方法，一个count属性和通过下标来查找一个自己的元素。这三个功能都达到Container协议的要求。也就意味着你可以扩展Array去遵循Container协议，只要通过简单声明Array适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳][7]中有描述这样一个实现一个空扩展的行为：
      
+
      extension Array: Container {}
+
      如同上面的泛型Stack类型一样，Array的append方法和下标保证Swift可以推断出ItemType所使用的适用的类型。定义了这个扩展后，你可以将任何Array当作Container来使用。
      
+
      
 
      Where 语句
      
-
      [Type Constraints][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
      
-
      对于关联类型的定义需求也是非常有用的。你可以通过这样去定义where语句作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置where关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
      
-
      下面的列子定义了一个名为allItemsMatch的泛型函数，用来检查是否两个Container单例包含具有相同顺序的相同items。如果匹配到所有的items，那么返回一个为true的Boolean值，反之，则相反。
      
-
      这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但他们确实拥有相同类型的items。这个需求通过一个类型约束和where语句结合来表示：
      
-
      func allItemsMatch<
+
      [类型约束][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
      
+
      对于关联类型的定义需求也是非常有用的。你可以通过这样去定义where语句作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置where关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
      
+
      下面的列子定义了一个名为allItemsMatch的泛型函数，用来检查是否两个Container单例包含具有相同顺序的相同元素。如果匹配到所有的元素，那么返回一个为true的Boolean值，反之，则相反。
      
+
      这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但他们确实拥有相同类型的元素。这个需求通过一个类型约束和where语句结合来表示：
      
+
      func allItemsMatch<
     C1: Container, C2: Container
     where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
     (someContainer: C1, anotherContainer: C2) -> Bool {
 
-        // check that both containers contain the same number of items
-        if someContainer.count != anotherContainer.count {
-            return false
+        // check that both containers contain the same number of items
+        if someContainer.count != anotherContainer.count {
+            return false
         }
 
-        // check each pair of items to see if they are equivalent
-        for i in 0..someContainer.count {
-            if someContainer[i] != anotherContainer[i] {
-                return false
+        // check each pair of items to see if they are equivalent
+        for i in 0..someContainer.count {
+            if someContainer[i] != anotherContainer[i] {
+                return false
             }
         }
 
-        // all items match, so return true
-        return true
+        // all items match, so return true
+        return true
 
 }
-
      
-
      这个函数用了两个参数：someContainer和anotherContainer。someContainer参数是类型C1，anotherContainer参数是类型C2。C1和C2是容器的两个节点类型参数，决定了这个函数何时被调用。
      
+
      这个函数用了两个参数：someContainer和anotherContainer。someContainer参数是类型C1，anotherContainer参数是类型C2。C1和C2是容器的两个占位类型参数，决定了这个函数何时被调用。
      
 
      这个函数的类型参数列紧随在两个类型参数需求的后面：
      
 
        
 
      • C1必须遵循Container协议 (写作 C1: Container)。
        • 
@@ -917,34 +906,32 @@ let stringIndex = findIndex(["Mike", C1的ItemType同样是C2的ItemType（写作 C1.ItemType == C2.ItemType）。
 
      • C1的ItemType必须遵循Equatable协议 (写作 C1.ItemType: Equatable)。
        • 
 
      
-
      第三个和第四个要求被定义为一个where语句的一部分，写在关键字where后面，作为函数类型参数链的一部分。
      
+
      第三个和第四个要求被定义为一个where语句的一部分，写在关键字where后面，作为函数类型参数链的一部分。
      
 
      这些要求意思是：
      
 
      someContainer是一个C1类型的容器。
 anotherContainer是一个C2类型的容器。
-someContainer和anotherContainer包含相同的items类型。
-someContainer中的items可以通过不等于操作(!=)来检查它们是否彼此不同。
      
-
      第三个和第四个要求结合起来的意思是anotherContainer中的items也可以通过 != 操作来检查，因为他们在someContainer中items确实是相同的类型。
      
+someContainer和anotherContainer包含相同的元素类型。
+someContainer中的元素可以通过不等于操作(!=)来检查它们是否彼此不同。
      
+
      第三个和第四个要求结合起来的意思是anotherContainer中的元素也可以通过 != 操作来检查，因为他们在someContainer中元素确实是相同的类型。
      
 
      这些要求能够使allItemsMatch函数比较两个容器，即便他们是不同的容器类型。
      
-
      allItemsMatch首先检查两个容器是否拥有同样数目的items，如果他们的items数目不同，没有办法进行匹配，函数就会false。
      
-
      检查完之后，函数通过for-in循环和半闭区间操作(..)来迭代someContainer中的所有items。对于每个item，函数检查是否someContainer中的item不等于对应的anotherContainer中的item，如果这两个items不等，则这两个容器不匹配，返回false。
      
-
      如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回true。
      
-
      Here’s how the allItemsMatch function looks in action:
-这里演示了allItemsMatch函数运算的过程：
      
-
      var stackOfStrings = Stack<String>()
-stackOfStrings.push("uno")
-stackOfStrings.push("dos")
-stackOfStrings.push("tres")
+
      allItemsMatch首先检查两个容器是否拥有同样数目的items，如果他们的元素数目不同，没有办法进行匹配，函数就会false。
      
+
      检查完之后，函数通过for-in循环和半闭区间操作（..）来迭代someContainer中的所有元素。对于每个元素，函数检查是否someContainer中的元素不等于对应的anotherContainer中的元素，如果这两个元素不等，则这两个容器不匹配，返回false。
      
+
      如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回true。
      
+
      这里演示了allItemsMatch函数运算的过程：
      
+
      var stackOfStrings = Stack<String>()
+stackOfStrings.push("uno")
+stackOfStrings.push("dos")
+stackOfStrings.push("tres")
 
-var arrayOfStrings = ["uno", "dos", "tres"]
+var arrayOfStrings = ["uno", "dos", "tres"]
 
-if allItemsMatch(stackOfStrings, arrayOfStrings) {
-    println("All items match.")
-} else {
-    println("Not all items match.")
+if allItemsMatch(stackOfStrings, arrayOfStrings) {
+    println("All items match.")
+} else {
+    println("Not all items match.")
 }
-// prints "All items match."
-
      
-
       上面的例子创建一个Stack单例来存储String，然后压了三个字符串进栈。这个例子也创建了一个Array单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但他们都遵循Container协议，而且他们都包含同样的类型值。你因此可以调用allItemsMatch函数，用这两个容器作为它的参数。在上面的例子中，allItemsMatch函数正确的显示了所有的这两个容器的items匹配。
      
+// 输出 "All items match."
+
       上面的例子创建一个Stack单例来存储String，然后压了三个字符串进栈。这个例子也创建了一个Array单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但他们都遵循Container协议，而且他们都包含同样的类型值。你因此可以调用allItemsMatch函数，用这两个容器作为它的参数。在上面的例子中，allItemsMatch函数正确的显示了所有的这两个容器的items匹配。
      
 
                     
                     
    
@@ -990,6 +977,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter2/23_Advanced_Operators.html b/chapter2/23_Advanced_Operators.html
index 7e376851..df7fde99 100644
--- a/chapter2/23_Advanced_Operators.html
+++ b/chapter2/23_Advanced_Operators.html
@@ -5,12 +5,12 @@
         
         
         
-        高级操作符 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
    
+    
    
     
    
     
     
@@ -98,7 +98,7 @@
     
     
    
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
    
 
    
 
@@ -119,7 +119,7 @@
         
 
         
  • 
-             Introduction
+             序
         
    • 
         
     
@@ -331,7 +331,7 @@
         
  • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,9 +587,13 @@
 
                 
    
                 
-                    
    
+                    
    
                     
-                        
    高级运算符
    
+                        
    
+
    翻译：xielingwang
    
+
    校对：numbbbbb
    
+
    
+
    高级运算符
    
 
    
 
    本页内容包括：
    
 
-
    In addition to the operators described in Basic Operators, Swift provides several advanced operators that perform more complex value manipulation. These include all of the bitwise and bit shifting operators you will be familiar with from C and Objective-C.
    
 
    除了基本操作符中所讲的运算符，Swift还有许多复杂的高级运算符，包括了C语和Objective-C中的位运算符和移位运算。
    
-
    Unlike arithmetic operators in C, arithmetic operators in Swift do not overflow by default. Overflow behavior is trapped and reported as an error. To opt in to overflow behavior, use Swift’s second set of arithmetic operators that overflow by default, such as the overflow addition operator (&+). All of these overflow operators begin with an ampersand (&).
    
 
    不同于C语言中的数值计算，Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用Swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加&+。所有允许溢出的运算符都是以&开始的。
    
-
    When you define your own structures, classes, and enumerations, it can be useful to provide your own implementations of the standard Swift operators for these custom types. Swift makes it easy to provide tailored implementations of these operators and to determine exactly what their behavior should be for each type you create.
    
 
    自定义的结构，类和枚举，是否可以使用标准的运算符来定义操作？当然可以！在Swift中，你可以为你创建的所有类型定制运算符的操作。
    
-
    You’re not just limited to the predefined operators. Swift gives you the freedom to define your own custom infix, prefix, postfix, and assignment operators, with custom precedence and associativity values. These operators can be used and adopted in your code just like any of the predefined operators, and you can even extend existing types to support the custom operators you define.
    
 
    可定制的运算符并不限于那些预设的运算符，自定义有个性的中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符，也可以运用之前定制的运算符。
    
-
    Bitwise Operators
    
 
    
 
    位运算符
    
-
    Bitwise operators enable you to manipulate the individual raw data bits within a data structure. They are often used in low-level programming, such as graphics programming and device driver creation. Bitwise operators can also be useful when you work with raw data from external sources, such as encoding and decoding data for communication over a custom protocol.
    
 
    位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候，运用位运算符来对原始数据进行编码和解码也是非常有效的。
    
-
    Swift supports all of the bitwise operators found in C, as described below.
    
 
    Swift支持如下所有C语言的位运算符：
    
-
    Bitwise NOT Operator
    
 
    按位取反运算符
    
-
    The bitwise NOT operator (~) inverts all bits in a number:
    
 
    按位取反运算符~对一个操作数的每一位都取反。
    
 
    Art/bitwiseNOT_2x.png
    
-
    The bitwise NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space:
    
 
    这个运算符是前置的，所以请不加任何空格地写着操作数之前。
    
 
    let initialBits: UInt8 = 0b00001111
 let invertedBits = ~initialBits  // 等于 0b11110000
-
    UInt8 integers have eight bits and can store any value between 0 and 255. This example initializes a UInt8 integer with the binary value 00001111, which has its first four bits set to 0, and its second four bits set to 1. This is equivalent to a decimal value of 15.
    
-
    UInt8是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值00001111(前4位为0，后4位为1)，它的十进制值为15。
    
-
    The bitwise NOT operator is then used to create a new constant called invertedBits, which is equal to initialBits, but with all of the bits inverted. Zeroes become ones, and ones become zeroes. The value of invertedBits is 11110000, which is equal to an unsigned decimal value of 240.
    
+

    • UInt8是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值00001111(前4位为0，后4位为1)，它的十进制值为15。

    使用按位取反运算~对initialBits操作，然后赋值给invertedBits这个新常量。这个新常量的值等于所有位都取反的initialBits，即1变成0，0变成1，变成了11110000，十进制值为240。

    -

    Bitwise AND Operator

    按位与运算符

    -

    The bitwise AND operator (&) combines the bits of two numbers. It returns a new number whose bits are set to 1 only if the bits were equal to 1 in both input numbers:

    按位与运算符对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为1时才为1。

    Art/bitwiseAND_2x.png

    -

    In the example below, the values of firstSixBits and lastSixBits both have four middle bits equal to 1. The bitwise AND operator combines them to make the number 00111100, which is equal to an unsigned decimal value of 60:

    以下代码，firstSixBits和lastSixBits中间4个位都为1。对它俩进行按位与运算后，就得到了00111100，即十进制的60。

    let firstSixBits: UInt8 = 0b11111100
 let lastSixBits: UInt8  = 0b00111111
 let middleFourBits = firstSixBits & lastSixBits  // 等于 00111100
-

    Bitwise OR Operator

    -

    按位或运算

    -

    The bitwise OR operator (|) compares the bits of two numbers. The operator returns a new number whose bits are set to 1 if the bits are equal to 1 in either input number:

    +

    按位或运算

    按位或运算符|比较两个数，然后返回一个新的数，这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1)。

    Art/bitwiseOR_2x.png

    -

    In the example below, the values of someBits and moreBits have different bits set to 1. The bitwise OR operator combines them to make the number 11111110, which equals an unsigned decimal of 254:

    如下代码，someBits和moreBits在不同位上有1。按位或运行的结果是11111110，即十进制的254。

    let someBits: UInt8 = 0b10110010
 let moreBits: UInt8 = 0b01011110
 let combinedbits = someBits | moreBits  // 等于 11111110
-

    Bitwise XOR Operator

    -

    按位异或运算符

    -

    The bitwise XOR operator, or “exclusive OR operator” (^), compares the bits of two numbers. The operator returns a new number whose bits are set to 1 where the input bits are different and are set to 0 where the input bits are the same:

    +

    按位异或运算符

    按位异或运算符^比较两个数，然后返回一个数，这个数的每个位设为1的条件是两个输入数的同一位不同，如果相同就设为0。

    Art/bitwiseXOR_2x.png

    -

    In the example below, the values of firstBits and otherBits each have a bit set to 1 in a location that the other does not. The bitwise XOR operator sets both of these bits to 1 in its output value. All of the other bits in firstBits and otherBits match and are set to 0 in the output value:

    以下代码，firstBits和otherBits都有一个1跟另一个数不同的。所以按位异或的结果是把它这些位置为1，其他都置为0。

    let firstBits: UInt8 = 0b00010100
 let otherBits: UInt8 = 0b00000101
 let outputBits = firstBits ^ otherBits  // 等于 00010001
-

    Bitwise Left and Right Shift Operators

    -

    按位左移/右移运算符

    -

    The bitwise left shift operator (<<) and bitwise right shift operator (>>) move all bits in a number to the left or the right by a certain number of places, according to the rules defined below.

    +

    按位左移/右移运算符

    左移运算符<<和右移运算符>>会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。

    -

    Bitwise left and right shifts have the effect of multiplying or dividing an integer number by a factor of two. Shifting an integer’s bits to the left by one position doubles its value, whereas shifting it to the right by one position halves its value.

    按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为2的整数。向左移动一个整型的比特位相当于把这个数乘于2，向右移一位就是除于2。

    -

    Shifting Behavior for Unsigned Integers

    无符整型的移位操作

    -

    The bit-shifting behavior for unsigned integers is as follows: -对无符整型的移位的效果如下：

    -

    Existing bits are moved to the left or right by the requested number of places. -Any bits that are moved beyond the bounds of the integer’s storage are discarded. -Zeroes are inserted in the spaces left behind after the original bits are moved to the left or right. -This approach is known as a logical shift.

    +

    对无符整型的移位的效果如下：

    已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃，移动留下的空白位用零0来填充。这种方法称为逻辑移位。

    -

    The illustration below shows the results of 11111111 << 1 (which is 11111111 shifted to the left by 1 place), and 11111111 >> 1 (which is 11111111 shifted to the right by 1 place). Blue numbers are shifted, gray numbers are discarded, and orange zeroes are inserted:

    以下这张把展示了 11111111 << 1(11111111向左移1位)，和 11111111 >> 1(11111111向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的0是被填充进来的。

    -

    Art/bitshiftUnsigned_2x.png -Here’s how bit shifting looks in Swift code:

    +

    Art/bitshiftUnsigned_2x.png

    let shiftBits: UInt8 = 4   // 即二进制的00000100
 shiftBits << 1             // 00001000
 shiftBits << 2             // 00010000
 shiftBits << 5             // 10000000
 shiftBits << 6             // 00000000
 shiftBits >> 2             // 00000001
-

    You can use bit shifting to encode and decode values within other data types: -你可以使用移位操作进行其他数据类型的编码和解码。

    +

    你可以使用移位操作进行其他数据类型的编码和解码。

    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
-

    This example uses a UInt32 constant called pink to store a Cascading Style Sheets color value for the color pink. The CSS color value #CC6699 is written as 0xCC6699 in Swift’s hexadecimal number representation. This color is then decomposed into its red (CC), green (66), and blue (99) components by the bitwise AND operator (&) and the bitwise right shift operator (>>).

    -

    这个例子使用了一个UInt32的命名为pink的常量来存储层叠样式表CSS中粉色的颜色值，CSS颜色#CC6699在Swift用十六进制0xCC6699来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。

    -

    The red component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0xFF0000. The zeroes in 0xFF0000 effectively “mask” the second and third bytes of 0xCC6699, causing the 6699 to be ignored and leaving 0xCC0000 as the result.

    +

    这个例子使用了一个UInt32的命名为pink的常量来存储层叠样式表CSS中粉色的颜色值，CSS颜色#CC6699在Swift用十六进制0xCC6699来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。

    对0xCC6699和0xFF0000进行按位与&操作就可以得到红色部分。0xFF0000中的0了遮盖了OxCC6699的第二和第三个字节，这样6699被忽略了，只留下0xCC0000。

    -

    This number is then shifted 16 places to the right (>> 16). Each pair of characters in a hexadecimal number uses 8 bits, so a move 16 places to the right will convert 0xCC0000 into 0x0000CC. This is the same as 0xCC, which has a decimal value of 204.

    然后，按向右移动16位，即 >> 16。十六进制中每两个字符是8比特位，所以移动16位的结果是把0xCC0000变成0x0000CC。这和0xCC是相等的，都是十进制的204。

    -

    Similarly, the green component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x00FF00, which gives an output value of 0x006600. This output value is then shifted eight places to the right, giving a a value of 0x66, which has a decimal value of 102.

    同样的，绿色部分来自于0xCC6699和0x00FF00的按位操作得到0x006600。然后向右移动8們，得到0x66，即十进制的102。

    -

    Finally, the blue component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x0000FF, which gives an output value of 0x000099. There’s no need to shift this to the right, as 0x000099 already equals 0x99, which has a decimal value of 153.

    最后，蓝色部分对0xCC6699和0x0000FF进行按位与运算，得到0x000099，无需向右移位了，所以结果就是0x99，即十进制的153。

    -

    Shifting Behavior for Signed Integers

    有符整型的移位操作

    -

    The shifting behavior is more complex for signed integers than for unsigned integers, because of the way signed integers are represented in binary. (The examples below are based on 8-bit signed integers for simplicity, but the same principles apply for signed integers of any size.)

    有符整型的移位操作相对复杂得多，因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的，但它的原理是通用的。)

    -

    Signed integers use their first bit (known as the sign bit) to indicate whether the integer is positive or negative. A sign bit of 0 means positive, and a sign bit of 1 means negative.

    有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。0代表正数，1代表负数。

    -

    The remaining bits (known as the value bits) store the actual value. Positive numbers are stored in exactly the same way as for unsigned integers, counting upwards from 0. Here’s how the bits inside an Int8 look for the number 4:

    其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的，下来我们来看+4内部的二进制结构。

    Art/bitshiftSignedFour_2x.png

    -

    The sign bit is 0 (meaning “positive”), and the seven value bits are just the number 4, written in binary notation.

    符号位为0，代表正数，另外7比特位二进制表示的实际值就刚好是4。

    -

    Negative numbers, however, are stored differently. They are stored by subtracting their absolute value from 2 to the power of n, where n is the number of value bits. An eight-bit number has seven value bits, so this means 2 to the power of 7, or 128.

    负数呢，跟正数不同。负数存储的是2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128。

    -

    Here’s how the bits inside an Int8 look for the number -4:

    我们来看-4存储的二进制结构。

    Art/bitshiftSignedMinusFour_2x.png

    -

    This time, the sign bit is 1 (meaning “negative”), and the seven value bits have a binary value of 124 (which is 128 - 4):

    现在符号位为1，代表负数，7个数值位要表达的二进制值是124，即128 - 4。

    Art/bitshiftSignedMinusFourValue_2x.png

    -

    The encoding for negative numbers is known as a two’s complement representation. It may seem an unusual way to represent negative numbers, but it has several advantages.

    负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪，但它有几个优点。

    -

    First, you can add -1 to -4, simply by performing a standard binary addition of all eight bits (including the sign bit), and discarding anything that doesn’t fit in the eight bits once you’re done:

    首先，只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 -1 + -4 的操作，忽略加法过程产生的超过8个比特位表达的任何信息。

    Art/bitshiftSignedAddition_2x.png

    -

    Second, the two’s complement representation also lets you shift the bits of negative numbers to the left and right like positive numbers, and still end up doubling them for every shift you make to the left, or halving them for every shift you make to the right. To achieve this, an extra rule is used when signed integers are shifted to the right:

    第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于2，右移1位时除于2。要达到此目的，对有符整型的右移有一个特别的要求：

    -

    When you shift signed integers to the right, apply the same rules as for unsigned integers, but fill any empty bits on the left with the sign bit, rather than with a zero.

    对有符整型按位右移时，使用符号位(正数为0，负数为1)填充空白位。

    Art/bitshiftSigned_2x.png

    -

    This action ensures that signed integers have the same sign after they are shifted to the right, and is known as an arithmetic shift.

    这就确保了在右移的过程中，有符整型的符号不会发生变化。这称为算术移位。

    -

    Because of the special way that positive and negative numbers are stored, shifting either of them to the right moves them closer to zero. Keeping the sign bit the same during this shift means that negative integers remain negative as their value moves closer to zero.

    正因为正数和负数特殊的存储方式，向右移位使它接近于0。移位过程中保持符号会不变，负数在接近0的过程中一直是负数。

    -

    Overflow Operators

    溢出运算符

    -

    If you try to insert a number into an integer constant or variable that cannot hold that value, by default Swift reports an error rather than allowing an invalid value to be created. This behavior gives extra safety when you work with numbers that are too large or too small.

    默认情况下，当你往一个整型常量或变量赋于一个它不能承载的大数时，Swift不会让你这么干的，它会报错。这样，在操作过大或过小的数的时候就很安全了。

    -

    For example, the Int16 integer type can hold any signed integer number between -32768 and 32767. Trying to set a UInt16 constant or variable to a number outside of this range causes an error:

    例如，Int16整型能承载的整数范围是-32768到32767，如果给它赋上超过这个范围的数，就会报错：

    var potentialOverflow = Int16.max
 // potentialOverflow 等于 32767, 这是 Int16 能承载的最大整数
 potentialOverflow += 1
 // 噢, 出错了
-

    Providing error handling when values get too large or too small gives you much more flexibility when coding for boundary value conditions.

    -

    对过大或过小的数值进行错误处理让你的数值边界条件更灵活。

    -

    However, when you specifically want an overflow condition to truncate the number of available bits, you can opt in to this behavior rather than triggering an error. Swift provides five arithmetic overflow operators that opt in to the overflow behavior for integer calculations. These operators all begin with an ampersand (&):

    +

    对过大或过小的数值进行错误处理让你的数值边界条件更灵活。

    当然，你有意在溢出时对有效位进行截断，你可采用溢出运算，而非错误处理。Swfit为整型计算提供了5个&符号开头的溢出运算符。

    • 溢出加法 &+
      • @@ -753,64 +700,46 @@ potentialOverflow += 1
    • 溢出除法 &/
    • 溢出求余 &%
    -

    Value Overflow

    值的上溢出

    -

    Here’s an example of what happens when an unsigned value is allowed to overflow, using the overflow addition operator (&+):

    下面例子使用了溢出加法&+来解剖的无符整数的上溢出

    var willOverflow = UInt8.max
 // willOverflow 等于UInt8的最大整数 255
 willOverflow = willOverflow &+ 1
 // 这时候 willOverflow 等于 0
-

    The variable willOverflow is initialized with the largest value a UInt8 can hold (255, or 11111111 in binary). It is then incremented by 1 using the overflow addition operator (&+). This pushes its binary representation just over the size that a UInt8 can hold, causing it to overflow beyond its bounds, as shown in the diagram below. The value that remains within the bounds of the UInt8 after the overflow addition is 00000000, or zero:

    -

    willOverflow用Int8所能承载的最大值255(二进制11111111)，然后用&+加1。然后UInt8就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在UInt8的承载范围内的那部分是00000000，也就是0。

    +

    willOverflow用Int8所能承载的最大值255(二进制11111111)，然后用&+加1。然后UInt8就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在UInt8的承载范围内的那部分是00000000，也就是0。

    Art/overflowAddition_2x.png

    -

    Value Underflow

    值的下溢出

    -

    Numbers can also become too small to fit in their type’s maximum bounds. Here’s an example. -数值也有可能因为太小而越界。举个例子：

    -

    The smallest value that a UInt8 can hold is 0 (which is 00000000 in eight-bit binary form). If you subtract 1 from 00000000 using the overflow subtraction operator, the number will overflow back round to 11111111, or 255 in decimal:

    +

    数值也有可能因为太小而越界。举个例子：

    UInt8的最小值是0(二进制为00000000)。使用&-进行溢出减1，就会得到二进制的11111111即十进制的255。

    Art/overflowUnsignedSubtraction_2x.png

    -

    Here’s how that looks in Swift code: -Swift代码是这样的:

    +

    Swift代码是这样的:

    var willUnderflow = UInt8.min
 // willUnderflow 等于UInt8的最小值0
 willUnderflow = willUnderflow &- 1
 // 此时 willUnderflow 等于 255
-

    A similar underflow occurs for signed integers. All subtraction for signed integers is performed as straight binary subtraction, with the sign bit included as part of the numbers being subtracted, as described in Bitwise Left and Right Shift Operators. The smallest number that an Int8 can hold is -128, which is 10000000 in binary. Subtracting 1 from this binary number with the overflow operator gives a binary value of 01111111, which toggles the sign bit and gives positive 127, the largest positive value that an Int8 can hold:

    -

    有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是-128，即二进制的10000000。用溢出减法减去去1后，变成了01111111，即UInt8所能承载的最大整数127。

    +

    有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是-128，即二进制的10000000。用溢出减法减去去1后，变成了01111111，即UInt8所能承载的最大整数127。

    Art/overflowSignedSubtraction_2x.png

    -

    Here’s the same thing in Swift code:

    来看看Swift代码：

    var signedUnderflow = Int8.min
 // signedUnderflow 等于最小的有符整数 -128
 signedUnderflow = signedUnderflow &- 1
 // 如今 signedUnderflow 等于 127
-

    The end result of the overflow and underflow behavior described above is that for both signed and unsigned integers, overflow always wraps around from the largest valid integer value back to the smallest, and underflow always wraps around from the smallest value to the largest.

    -

    Division by Zero

    -

    除零溢出

    -

    Dividing a number by zero(i / 0), or trying to calculate remainder by zero(i % 0), causes an error:

    +

    除零溢出

    一个数除于0 i / 0，或者对0求余数 i % 0，就会产生一个错误。

    let x = 1
 let y = x / 0
-

    However, the overflow versions of these operators (&/ and &%) return a value of zero if you divide by zero:

    -

    使用它们对应的可溢出的版本的运算符&/和&%进行除0操作时就会得到0值。

    +

    使用它们对应的可溢出的版本的运算符&/和&%进行除0操作时就会得到0值。

    let x = 1
 let y = x &/ 0
 // y 等于 0
-

    Precedence and Associativity

    -

    +

    优先级和结合性

    -

    Operator precedence gives some operators higher priority than others; these operators are calculated first.

    运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。

    -

    Operator associativity defines how operators of the same precedence are grouped together (or associated)—either grouped from the left, or grouped from the right. Think of it as meaning “they associate with the expression to their left,” or “they associate with the expression to their right.”

    结合性定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？

    -

    It is important to consider each operator’s precedence and associativity when working out the order in which a compound expression will be calculated. Here’s an example. Why does the following expression equal 4?

    在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为4？

    2 + 3 * 4 % 5
 // 结果是 4
-

    Taken strictly from left to right, you might expect this to read as follows:

    -

    如果严格地从左计算到右，计算过程会是这样：

    +

    如果严格地从左计算到右，计算过程会是这样：

    • 2 plus 3 equals 5;
    • 2 + 3 = 5
      • @@ -819,9 +748,7 @@ let y = x &/ 0
    • 20 remainder 5 equals 0
    • 20 / 5 = 4 余 0
    -

    However, the actual answer is 4, not 0. Higher-precedence operators are evaluated before lower-precedence ones. In Swift, as in C, the multiplication operator (*) and the remainder operator (%) have a higher precedence than the addition operator (+). As a result, they are both evaluated before the addition is considered.

    但是正确答案是4而不是0。优先级高的运算符要先计算，在Swift和C语言中，都是先乘除后加减的。所以，执行完乘法和求余运算才能执行加减运算。

    -

    However, multiplication and remainder have the same precedence as each other. To work out the exact evaluation order to use, you also need to consider their associativity. Multiplication and remainder both associate with the expression to their left. Think of this as adding implicit parentheses around these parts of the expression, starting from their left:

    乘法和求余拥有相同的优先级，在运算过程中，我们还需要结合性，乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。

    2 + ((3 * 4) % 5)

    (3 4) is 12, so this is equivalent to: @@ -830,23 +757,15 @@ let y = x &/ 0

    (12 % 5) is 2, so this is equivalent to: 12 % 5 = 2，所这又相当于

    2 + 2
-

    This calculation yields the final answer of 4.

    -

    计算结果为 4。

    -

    For a complete list of Swift operator precedences and associativity rules, see Expressions.

    +

    计算结果为 4。

    查阅Swift运算符的优先级和结合性的完整列表，请看表达式。

    -

    NOTE

    -

    Swift’s operator precedences and associativity rules are simpler and more predictable than those found in C and Objective-C. However, this means that they are not the same as in C-based languages. Be careful to ensure that operator interactions still behave in the way you intend when porting existing code to Swift.

    -

    注意： -Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。

    +

    注意：

    +

    Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。

    -

    Operator Functions

    运算符函数

    -

    Classes and structures can provide their own implementations of existing operators. This is known as overloading the existing operators.

    让已有的运算符也可以对自定义的类和结构进行运算，这称为运算符重载。

    -

    The example below shows how to implement the arithmetic addition operator (+) for a custom structure. The arithmetic addition operator is a binary operator because it operates on two targets and is said to be infix because it appears in between those two targets.

    -

    The example defines a Vector2D structure for a two-dimensional position vector (x, y), followed by a definition of an operator function to add together instances of the Vector2D structure:

    这个例子展示了如何用+让一个自定义的结构做加法。算术运算符+是一个两目运算符，因为它有两个操作数，而且它必须出现在两个操作数之间。

    例子中定义了一个名为Vector2D的二维坐标向量 (x，y) 的结构，然后定义了让两个Vector2D的对象相加的运算符函数。

    struct Vector2D {
@@ -855,74 +774,54 @@ Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着
 @infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
     return Vector2D(x: left.x + right.x, y: left.y + right.y)
 }
-

    The operator function is defined as a global function called +, which takes two input parameters of type Vector2D and returns a single output value, also of type Vector2D. You implement an infix operator by writing the @infix attribute before the func keyword when declaring the operator function.

    -

    该运算符函数定义了一个全局的+函数，这个函数需要两个Vector2D类型的参数，返回值也是Vector2D类型。需要定义和实现一个中置运算的时候，在关键字func之前写上属性 @infix 就可以了。

    -

    In this implementation, the input parameters are named left and right to represent the Vector2D instances that will be on the left side and right side of the + operator. The function returns a new Vector2D instance, whose x and y properties are initialized with the sum of the x and y properties from the two Vector2D instances that are added together.

    +

    该运算符函数定义了一个全局的+函数，这个函数需要两个Vector2D类型的参数，返回值也是Vector2D类型。需要定义和实现一个中置运算的时候，在关键字func之前写上属性 @infix 就可以了。

    在这个代码实现中，参数被命名为了left和right，代表+左边和右边的两个Vector2D对象。函数返回了一个新的Vector2D的对象，这个对象的x和y分别等于两个参数对象的x和y的和。

    -

    The function is defined globally, rather than as a method on the Vector2D structure, so that it can be used as an infix operator between existing Vector2D instances:

    这个函数是全局的，而不是Vector2D结构的成员方法，所以任意两个Vector2D对象都可以使用这个中置运算符。

    let vector = Vector2D(x: 3.0, y: 1.0)
 let anotherVector = Vector2D(x: 2.0, y: 4.0)
 let combinedVector = vector + anotherVector
 // combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0)
-

    This example adds together the vectors (3.0, 1.0) and (2.0, 4.0) to make the vector (5.0, 5.0), as illustrated below.

    -

    这个例子实现两个向量 (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

    -

    Prefix and Postfix Operators

    前置和后置运算符

    -

    The example shown above demonstrates a custom implementation of a binary infix operator. Classes and structures can also provide implementations of the standard unary operators. Unary operators operate on a single target. They are prefix if they precede their target (such as -a) and postfix operators if they follow their target (such as i++).

    -

    You implement a prefix or postfix unary operator by writing the @prefix or @postfix attribute before the func keyword when declaring the operator function:

    上个例子演示了一个双目中置运算符的自定义实现，同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数，在操作数之前就是前置的，如-a; 在操作数之后就是后置的，如i++。

    实现一个前置或后置运算符时，在定义该运算符的时候于关键字func之前标注 @prefix 或 @postfix 属性。

    @prefix func - (vector: Vector2D) -> Vector2D {
     return Vector2D(x: -vector.x, y: -vector.y)
 }
-

    The example above implements the unary minus operator (-a) for Vector2D instances. The unary minus operator is a prefix operator, and so this function has to be qualified with the @prefix attribute.

    -

    这段代码为Vector2D类型提供了单目减运算-a，@prefix属性表明这是个前置运算符。

    -

    For simple numeric values, the unary minus operator converts positive numbers into their negative equivalent and vice versa. The corresponding implementation for Vector2D instances performs this operation on both the x and y properties:

    +

    这段代码为Vector2D类型提供了单目减运算-a，@prefix属性表明这是个前置运算符。

    对于数值，单目减运算符可以把正数变负数，把负数变正数。对于Vector2D，单目减运算将其x和y都进进行单目减运算。

    let positive = Vector2D(x: 3.0, y: 4.0)
 let negative = -positive
 // negative 为 (-3.0, -4.0)
 let alsoPositive = -negative
 // alsoPositive 为 (3.0, 4.0)
-

    Compound Assignment Operators

    -

    组合赋值运算符

    -

    Compound assignment operators combine assignment (=) with another operation. For example, the addition assignment operator (+=) combines addition and assignment into a single operation. Operator functions that implement compound assignment must be qualified with the @assignment attribute. You must also mark a compound assignment operator’s left input parameter as inout, because the parameter’s value will be modified directly from within the operator function.

    -

    The example below implements an addition assignment operator function for Vector2D instances:

    +

    组合赋值运算符

    组合赋值是其他运算符和赋值运算符一起执行的运算。如+=把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用@assignment属性，还需要把运算符的左参数设置成inout，因为这个参数会在运算符函数内直接修改它的值。

    @assignment func += (inout left: Vector2D, right: Vector2D) {
     left = left + right
 }
-

    Because an addition operator was defined earlier, you don’t need to reimplement the addition process here. Instead, the addition assignment operator function takes advantage of the existing addition operator function, and uses it to set the left value to be the left value plus the right value:

    -

    因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。

    +

    因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。

    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)
-

    You can combine the @assignment attribute with either the @prefix or @postfix attribute, as in this implementation of the prefix increment operator (++a) for Vector2D instances:

    -

    你可以将 @assignment 属性和 @prefix 或 @postfix 属性起来组合，实现一个Vector2D的前置运算符。

    +

    你可以将 @assignment 属性和 @prefix 或 @postfix 属性起来组合，实现一个Vector2D的前置运算符。

    @prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D {
     vector += Vector2D(x: 1.0, y: 1.0)
     return vector
 }
-

    The prefix increment operator function above takes advantage of the addition assignment operator defined earlier. It adds a Vector2D with x and y values of 1.0 to the Vector2D on which it is called, and returns the result:

    -

    这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 (1.0，1.0) 的对象然后赋给自己，然后再将自己返回。

    +

    这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 (1.0，1.0) 的对象然后赋给自己，然后再将自己返回。

    var toIncrement = Vector2D(x: 3.0, y: 4.0)
 let afterIncrement = ++toIncrement
 // toIncrement 现在是 (4.0, 5.0)
 // afterIncrement 现在也是 (4.0, 5.0)
    -

    NOTE

    -

    It is not possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded. Similarly, the ternary conditional operator (a ? b : c) cannot be overloaded.

    -

    注意： -默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 a？b：c 也是不可重载。

    +

    注意：

    +

    默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 a？b：c 也是不可重载。

    -

    Equivalence Operators

    比较运算符

    -

    Custom classes and structures do not receive a default implementation of the equivalence operators, known as the “equal to” operator (==) and “not equal to” operator (!=). It is not possible for Swift to guess what would qualify as “equal” for your own custom types, because the meaning of “equal” depends on the roles that those types play in your code.

    Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符==或!=就需要重载。

    -

    To use the equivalence operators to check for equivalence of your own custom type, provide an implementation of the operators in the same way as for other infix operators:

    定义相等运算符函数跟定义其他中置运算符雷同：

    @infix func == (left: Vector2D, right: Vector2D) -> Bool {
     return (left.x == right.x) && (left.y == right.y)
@@ -931,9 +830,7 @@ let afterIncrement = ++toIncrement
 @infix func != (left: Vector2D, right: Vector2D) -> Bool {
     return !(left == right)
 }
-

    The above example implements an “equal to” operator (==) to check if two Vector2D instances have equivalent values. In the context of Vector2D, it makes sense to consider “equal” as meaning “both instances have the same x values and y values”, and so this is the logic used by the operator implementation. The example also implements the “not equal to” operator (!=), which simply returns the inverse of the result of the “equal to” operator.

    -

    上述代码实现了相等运算符==来判断两个Vector2D对象是否有相等的值，相等的概念就是他们有相同的x值和相同的y值，我们就用这个逻辑来实现。接着使用==的结果实现了不相等运算符!=。

    -

    You can now use these operators to check whether two Vector2D instances are equivalent:

    +

    上述代码实现了相等运算符==来判断两个Vector2D对象是否有相等的值，相等的概念就是他们有相同的x值和相同的y值，我们就用这个逻辑来实现。接着使用==的结果实现了不相等运算符!=。

    现在我们可以使用这两个运算符来判断两个Vector2D对象是否相等。

    let twoThree = Vector2D(x: 2.0, y: 3.0)
 let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
@@ -941,34 +838,24 @@ if twoThree == anotherTwoThree {
     println("这两个向量是相等的.")
 }
 // prints "这两个向量是相等的."
-

    Custom Operators

    -

    自定义运算符

    -

    You can declare and implement your own custom operators in addition to the standard operators provided by Swift. Custom operators can be defined only with the characters / = - + * % < > ! & | ^ . ~.

    +

    自定义运算符

    标准的运算符不够玩，那你可以声明一些个性的运算符，但个性的运算符只能使用这些字符 / = - + * % < >！& | ^。~。

    -

    New operators are declared at a global level using the operator keyword, and can be declared as prefix, infix or postfix:

    新的运算符声明需在全局域使用operator关键字声明，可以声明为前置，中置或后置的。

    operator prefix +++ {}
-

    The example above defines a new prefix operator called +++. This operator does not have an existing meaning in Swift, and so it is given its own custom meaning below in the specific context of working with Vector2D instances. For the purposes of this example, +++ is treated as a new “prefix doubling incrementer” operator. It doubles the x and y values of a Vector2D instance, by adding the vector to itself with the addition assignment operator defined earlier:

    -

    这段代码定义了一个新的前置运算符叫+++，此前Swift并不存在这个运算符。此处为了演示，我们让+++对Vector2D对象的操作定义为 双自增 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。

    +

    这段代码定义了一个新的前置运算符叫+++，此前Swift并不存在这个运算符。此处为了演示，我们让+++对Vector2D对象的操作定义为 双自增 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。

    @prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D {
     vector += vector
     return vector
 }
-

    This implementation of +++ is very similar to the implementation of ++ for Vector2D, except that this operator function adds the vector to itself, rather than adding Vector2D(1.0, 1.0):

    -

    Vector2D 的 +++ 的实现和 ++ 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 (1.0, 1.0) 的向量.

    +

    Vector2D 的 +++ 的实现和 ++ 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 (1.0, 1.0) 的向量.

    var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
 let afterDoubling = +++toBeDoubled
 // toBeDoubled 现在是 (2.0, 8.0)
 // afterDoubling 现在也是 (2.0, 8.0)
-

    Precedence and Associativity for Custom Infix Operators

    -

    自定义中置运算符的优先级和结合性

    -

    Custom infix operators can also specify a precedence and an associativity. See Precedence and Associativity for an explanation of how these two characteristics affect an infix operator’s interaction with other infix operators.

    +

    自定义中置运算符的优先级和结合性

    可以为自定义的中置运算符指定优先级和结合性。可以回头看看优先级和结合性解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。

    -

    The possible values for associativity are left, right, and none. Left-associative operators associate to the left if written next to other left-associative operators of the same precedence. Similarly, right-associative operators associate to the right if written next to other right-associative operators of the same precedence. Non-associative operators cannot be written next to other operators with the same precedence.

    结合性(associativity)的值可取的值有left，right和none。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。

    -

    The associativity value defaults to none if it is not specified. The precedence value defaults to 100 if it is not specified.

    结合性(associativity)的值默认为none，优先级(precedence)默认为100。

    -

    The following example defines a new custom infix operator called +-, with left associativity and a precedence of 140:

    以下例子定义了一个新的中置符+-，是左结合的left，优先级为140。

    operator infix +- { associativity left precedence 140 }
 func +- (left: Vector2D, right: Vector2D) -> Vector2D {
@@ -978,8 +865,7 @@ 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)
-

    This operator adds together the x values of two vectors, and subtracts the y value of the second vector from the first. Because it is in essence an “additive” operator, it has been given the same associativity and precedence values (left and 140) as default additive infix operators such as + and -. For a complete list of the default Swift operator precedence and associativity settings, see Expressions.

    -

    这个运算符把两个向量的x相加，把向量的y相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(left和140)。查阅完整的Swift默认结合性和优先级的设置，请移步表达式;

    +

    这个运算符把两个向量的x相加，把向量的y相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(left和140)。查阅完整的Swift默认结合性和优先级的设置，请移步表达式;

    @@ -1025,6 +911,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter2/chapter2.html b/chapter2/chapter2.html index 5a89dad1..2411f26a 100644 --- a/chapter2/chapter2.html +++ b/chapter2/chapter2.html @@ -5,12 +5,12 @@ - Swift 教程 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,7 +587,7 @@
    -
    +

    Swift 教程

    本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。

    @@ -636,6 +636,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter3/01_About_the_Language_Reference.html b/chapter3/01_About_the_Language_Reference.html index 401ba308..e560eae7 100644 --- a/chapter3/01_About_the_Language_Reference.html +++ b/chapter3/01_About_the_Language_Reference.html @@ -5,12 +5,12 @@ - 关于语言参考 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,13 +587,22 @@
    -
    +
    -

    关于语言附注

    +
    +

    翻译：ChildhoodAndy

    +

    校对：numbbbbb

    +
    +

    关于语言附注

    +

    本页内容包括：

    +

    本书的这一节描述了Swift编程语言的形式语法。这里描述的语法是为了帮助您更详细的了解该语言，而不是让您直接实现一个解析器或编译器。

    Swift语言相对小点，这是由于在Swift代码中几乎无处不在的许多常见的的类型，函数以及运算符都由Swift标准库来定义。虽然这些类型，函数和运算符不是Swift语言本身的一部分，但是它们被广泛用于这本书的讨论和代码范例。

    -

    如何阅读语法

    +

    +

    如何阅读语法

    用来描述Swift编程语言形式语法的记法遵循下面几个约定：

    • -

    ================================================================ -上篇：高级操作符

    -

    下篇：词法结构

    @@ -662,6 +668,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter3/02_Lexical_Structure.html b/chapter3/02_Lexical_Structure.html index a88a42d4..1a9a57fc 100644 --- a/chapter3/02_Lexical_Structure.html +++ b/chapter3/02_Lexical_Structure.html @@ -5,12 +5,12 @@ - 词法结构 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,23 +587,29 @@
    -
    +
    -

    语法结构

    +
    +

    翻译：superkam

    +

    校对：numbbbbb

    +
    +

    词法结构

    本页包含内容：

    -

    Swift 的“语法结构（lexical structure）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。

    +

    Swift 的“词法结构（lexical structure）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。

    通常，标记在随后介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（longest match）”，或者“最大适合”（maximal munch）。

    +

    空白与注释

    空白（whitespace）有两个用途：分隔源文件中的标记和区分运算符属于前缀还是后缀，（参见 运算符）在其他情况下则会被忽略。以下的字符会被当作空白：空格（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）被编译器当作空白处理。单行注释由 // 开始直到该行结束。多行注释由 /* 开始，以 */ 结束。可以嵌套注释，但注意注释标记必须匹配。

    +

    标识符

    标识符（identifiers）可以由以下的字符开始：大写或小写的字母 A 到 Z、下划线 _、基本多语言面（Basic Multilingual Plane）中的 Unicode 非组合字符以及基本多语言面以外的非专用区（Private Use Area）字符。首字符之后，标识符允许使用数字和 Unicode 字符组合。

    使用保留字（reserved word）作为标识符，需要在其前后增加反引号 `。例如，class 不是合法的标识符，但可以使用 `class`。反引号不属于标识符的一部分，`x` 和 x 表示同一标识符。

    @@ -635,10 +641,11 @@

    identifier-characters → identifier-character ­identifier-characters­ opt­

    implicit-parameter-name → $­ decimal-digits­

    +

    关键字

    被保留的关键字（keywords）不允许用作标识符，除非被反引号转义，参见 标识符。

      -

    • 用作声明的关键字： class、deinit、enum、extension、func、import、init、let、protocol、static、struct、subscript、typealias、var

      +

    • 用作声明的关键字： 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

      • @@ -647,6 +654,7 @@

    • 特定上下文中被保留的关键字： associativity、didSet、get、infix、inout、left、mutating、none、nonmutating、operator、override、postfix、precedence、prefix、right、set、unowned、unowned(safe)、unowned(unsafe)、weak、willSet，这些关键字在特定上下文之外可以被用于标识符。

    +

    字面量

    字面值表示整型、浮点型数字或文本类型的值，举例如下：

    42                 // 整型字面量
@@ -750,6 +758,7 @@ var x = 3; "1 2 \(x)"
 
    escaped-character → \u ­hexadecimal-digit­ hexadecimal-digit ­hexadecimal-digit­ hexadecimal-digit­
    
 
    escaped-character → \U­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­ hexadecimal-digit­
    
 
+
    
 
    运算符
    
 
    Swift 标准库定义了许多可供使用的运算符，其中大部分在 基础运算符 和 高级运算符 中进行了阐述。这里将描述哪些字符能用作运算符。
    
 
    运算符由一个或多个以下字符组成：
@@ -766,7 +775,7 @@ var x = 3; "1 2 \(x)"

    • 鉴于这些规则，运算符前的字符 (、[ 和 { ；运算符后的字符 )、] 和 } 以及字符 ,、; 和 : 都将用于空白检测。

    -

    以上规则需注意一点，如果运算符 ! 或 ? 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 ? 用作可选类型（optional type）修饰，左侧必须无空白。如果用于条件运算符 ? :，必须两侧都有空白。

    +

    以上规则需注意一点，如果运算符 ! 或 ? 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 ? 用作可选类型（optional type）修饰，左侧必须无空白。如果用于条件运算符 ? :，必须两侧都有空白。

    在特定构成中 ，以 < 或 > 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 Dictionary<String, Array<Int>> 中没有必要添加空白来消除闭合字符 > 的歧义。在这个例子中， 闭合字符 > 被看作单字符标记，而不会被误解为移位运算符 >>。

    要学习如何自定义新的运算符，请参考 自定义操作符 和 运算符声明。学习如何重写现有运算符，请参考 运算符方法。

    @@ -822,6 +831,6 @@ require(["gitbook"], function(gitbook) { - + diff --git a/chapter3/03_Types.html b/chapter3/03_Types.html index 7672027d..d24005fc 100644 --- a/chapter3/03_Types.html +++ b/chapter3/03_Types.html @@ -5,12 +5,12 @@ - 类型 | Swift 编程语言 + 《The Swift Programming Language》中文版 - + @@ -21,8 +21,8 @@ - - + + @@ -46,7 +46,7 @@ -
    +
    @@ -98,7 +98,7 @@

    - Swift 编程语言 + 这一次，让中国和世界同步

    @@ -119,7 +119,7 @@
  • - Introduction + 序
    • @@ -331,7 +331,7 @@
  • - 2.19. 嵌套类型 + 2.19. 类型嵌套 @@ -534,7 +534,7 @@ - + @@ -587,43 +587,49 @@
    -
    +
    -

    类型（Types）

    +
    +

    翻译：lyuka

    +

    校对：numbbbbb

    +
    +

    类型（Types）

    本页包含内容：

    -

    Swift语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类MyClass的实例拥有类型MyClass。除了用户定义的命名型类型，Swift标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。

    -

    那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串——实际上就是命名型类型，Swift标准库是使用结构体定义和实现它们的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以适应你程序的需求。

    -

    复合型类型是没有名字的类型，它由Swift本身定义。Swift存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型(Int, (Int, Int))包含两个元素：第一个是命名型类型Int，第二个是另一个复合型类型(Int, Int).

    -

    本节讨论Swift语言本身定义的类型，并描述Swift中的类型推断行为。

    +

    Swift 语言存在两种类型：命名型类型和复合型类型。命名型类型是指定义时可以给定名字的类型。命名型类型包括类、结构体、枚举和协议。比如，一个用户定义的类MyClass的实例拥有类型MyClass。除了用户定义的命名型类型，Swift 标准库也定义了很多常用的命名型类型，包括那些表示数组、字典和可选值的类型。

    +

    那些通常被其它语言认为是基本或初级的数据型类型（Data types）——比如表示数字、字符和字符串——实际上就是命名型类型，Swift 标准库是使用结构体定义和实现它们的。因为它们是命名型类型，因此你可以按照“扩展和扩展声明”章节里讨论的那样，声明一个扩展来增加它们的行为以适应你程序的需求。

    +

    复合型类型是没有名字的类型，它由 Swift 本身定义。Swift 存在两种复合型类型：函数类型和元组类型。一个复合型类型可以包含命名型类型和其它复合型类型。例如，元组类型(Int, (Int, Int))包含两个元素：第一个是命名型类型Int，第二个是另一个复合型类型(Int, Int).

    +

    本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。

    类型的语法： type → array-type | function-type | type-identifier | tuple-type | optional-type | implicitly-unwrapped-optional-type | protocol-composition-type | metatype-type

    -

    类型标注

    -

    类型标注显式地指定一个变量或表达式的值。类型标注始于冒号:终于类型，比如下面两个例子：

    +

    +

    类型注解

    +

    类型注解显式地指定一个变量或表达式的值。类型注解始于冒号:终于类型，比如下面两个例子：

    let someTuple：(Double, Double) = (3.14159, 2.71828)
 func someFunction(a: Int){ /* ... */ }

    在第一个例子中，表达式someTuple的类型被指定为(Double, Double)。在第二个例子中，函数someFunction的参数a的类型被指定为Int。

    -

    类型标注可以在类型之前包含一个类型特性（type attributes）的可选列表。

    +

    类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。

    -

    类型标注的语法： +

    类型注解的语法： type-annotation → :attributes[opt] type

    +

    类型标识符

    类型标识符引用命名型类型或者是命名型/复合型类型的别名。

    大多数情况下，类型标识符引用的是同名的命名型类型。例如类型标识符Int引用命名型类型Int，同样，类型标识符Dictionary<String, Int>引用命名型类型Dictionary<String, Int>。

    @@ -639,6 +645,7 @@ func someFunction(a: Int){ /* ... */ } type-identifier → type-name generic-argument-clause[opt] | type-name generic-argument-clause[opt].type-identifier type-name → identifier

    • +

    元组类型

    元组类型使用逗号隔开并使用括号括起来的0个或多个类型组成的列表。

    你可以使用元组类型作为一个函数的返回类型，这样就可以使函数返回多个值。你也可以命名元组类型中的元素，然后用这些名字来引用每个元素的值。元素的名字由一个标识符和:组成。“函数和多返回值”章节里有一个展示上述特性的例子。

    @@ -647,10 +654,11 @@ func someFunction(a: Int){ /* ... */ }

    元组类型语法： tuple → (tuple-type-body[opt]) tuple-type-body → tuple-type-element-list ...[opt] -tuple-type-element-list → tuple-type-element | tuple-type-element, tuple-type-element-list -tuple-type-element → attributes[opt] inout [opt] type | inout [opt] element-name type-annotation +tuple-type-element-list → tuple-type-element | tuple-type-element, tuple-type-element-list +tuple-type-element → attributes[opt] inout [opt] type | inout [opt] element-name type-annotation element-name → identifier

    +

    函数类型

    函数类型表示一个函数、方法或闭包的类型，它由一个参数类型和返回值类型组成，中间用箭头->隔开：

      @@ -688,6 +696,7 @@ addTwoNumbers(4)(5函数类型的语法： function-type → type -> type

      +

      数组类型

      Swift语言使用类型名紧接中括号[]来简化标准库中定义的命名型类型Array<T>。换句话说，下面两个声明是等价的：

      let someArray: String[] = ["Alex", "Brian", "Dave"]
@@ -706,6 +715,7 @@ addTwoNumbers(4)(5数组类型的语法：
 array-type → type[ ] | array-type[ ]
      
 
+
      
 
      可选类型
      
 
      Swift定义后缀?来作为标准库中的定义的命名型类型Optional<T>的简写。换句话说，下面两个声明是等价的：
      
 
      var optionalInteger: Int?
@@ -726,6 +736,7 @@ optionalInteger!      // 42
 
      可选类型语法：
 optional-type → type?
      
 
+
      
 
      隐式解析可选类型
      
 
      Swift语言定义后缀!作为标准库中命名类型ImplicitlyUnwrappedOptional<T>的简写。换句话说，下面两个声明等价：
      
 
      var implicitlyUnwrappedString: String!
@@ -741,8 +752,9 @@ optionalInteger!      // 42
 
      隐式解析可选的语法：
 implicitly-unwrapped-optional-type → type!
      
 
+
      
 
      协议合成类型
      
-
      协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型标注和泛型参数中。
      
+
      协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。
      
 
      协议合成类型的形式如下：
      
 
      protocol<Protocol 1, Procotol 2>
 
      
@@ -751,9 +763,10 @@ implicitly-unwrapped-optional-type → type!
      
 
      
 
      协议合成类型的语法：
 protocol-composition-type → protocol <protocol-identifier-list[opt]>
-protocol-identifier-list → protocol-identifier | protocol-identifier, protocol-identifier-list 
+protocol-identifier-list → protocol-identifier | protocol-identifier, protocol-identifier-list
 protocol-identifier → type-identifier
      
 
      
+
      
 
      元类型
      
 
      元类型是指所有类型的类型，包括类、结构体、枚举和协议。
      
 
      类、结构体或枚举类型的元类型是相应的类型名紧跟.Type。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟.Protocol。比如，类SomeClass的元类型就是SomeClass.Type，协议SomeProtocol的元类型就是SomeProtocal.Protocol。
      
@@ -778,6 +791,7 @@ someInstance.dynamicType.printClassName()
 
      元类型的语法：
 metatype-type → type.Type | type.Protocol
      
 
+
      
 
      类型继承子句
      
 
      类型继承子句被用来指定一个命名型类型继承哪个类且适配哪些协议。类型继承子句开始于冒号:，紧跟由,隔开的类型标识符列表。
      
 
      类可以继承单个超类，适配任意数量的协议。当定义一个类时，超类的名字必须出现在类型标识符列表首位，然后跟上该类需要适配的任意数量的协议。如果一个类不是从其它类继承而来，那么列表可以以协议开头。关于类继承更多的讨论和例子，见章节“继承”。
      
@@ -785,13 +799,14 @@ someInstance.dynamicType.printClassName()
 
      枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。
      
 
      
 
      类型继承子句的语法：
-type-inheritance-clause → :type-inheritance-list 
+type-inheritance-clause → :type-inheritance-list
 type-inheritance-list → type-identifier | type-identifier, type-inheritance-list
      
 
      
+
      
 
      类型推断
      
 
      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）。
      
-
      在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量eFloat上的显式类型标注（:Float）导致数字字面量2.71828的类型是Float而非Double。
      
+
      在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量eFloat上的显式类型注解（:Float）导致数字字面量2.71828的类型是Float而非Double。
      
 
      let e = 2.71828 // The type of e is inferred to be Double.
 let eFloat: Float = 2.71828 // The type of eFloat is Float.
 
      
@@ -841,6 +856,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/04_Expressions.html b/chapter3/04_Expressions.html
index 6f9fc020..6e7b0a79 100644
--- a/chapter3/04_Expressions.html
+++ b/chapter3/04_Expressions.html
@@ -5,12 +5,12 @@
         
         
         
-        表达式 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
      
+    
      
     
      
     
     
@@ -98,7 +98,7 @@
     
     
      
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
      
 
      
 
@@ -119,7 +119,7 @@
         
 
         
    • 
-             Introduction
+             序
         
      • 
         
     
@@ -331,7 +331,7 @@
         
    • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,27 +587,41 @@
 
                 
      
                 
-                    
      
+                    
      
                     
-                        
      表达式(Expressions)
      
+                        
      
+
      翻译：sg552
      
+
      校对：numbbbbb
      
+
      
+
      表达式（Expressions）
      
 
      
-
      Swift 中存在四种表达式： 前缀(prefix)表达式，二元(binary)表达式，主要(primary)表达式和后缀(postfix)表达式。表达式可以返回一个值，以及运行某些逻辑(causes a side effect)。
      
-
      前缀表达式和二元表达式就是对某些表达式使用各种运算符(operators)。 主要表达式是最短小的表达式，它提供了获取(变量的)值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～
      
+
      本页包含内容：
      
+
        
+
      • [前缀表达式（Prefix Expressions）]
        • 
+
      • [二元表达式（Binary Expressions）]
        • 
+
      • [赋值表达式（Assignment Operator）]
        • 
+
      • [三元条件运算符（Ternary Conditional Operator）]
        • 
+
      • [类型转换运算符（Type-Casting Operators）]
        • 
+
      • [主要表达式（Primary Expressions）]
        • 
+
      • [后缀表达式（Postfix Expressions）]
        • 
+
      
+
      Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（causes a side effect）。
      
+
      前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～
      
 
      
 
      表达式的语法
      
-
      expression → prefix-expression­binary-expressions(opt)
+
      expression → prefix-expression­binary-expressions(opt)
 expression-list → expression­| expression­,­expression-list
      
 
      
-
      前缀表达式(Prefix Expressions)
      
-
      前缀表达式由 前缀符号和表达式组成。(这个前缀符号只能接收一个参数)
      
+
      前缀表达式（Prefix Expressions）
      
+
      前缀表达式由 前缀符号和表达式组成。（这个前缀符号只能接收一个参数）
      
 
      Swift 标准库支持如下的前缀操作符：
      
 
        
-
      • ++ 自增1 (increment)
        • 
-
      • -- 自减1 (decrement)
        • 
-
      • ! 逻辑否 (Logical NOT )
        • 
-
      • ~ 按位否 (Bitwise NOT )
        • 
-
      • + 加(Unary plus)
        • 
-
      • - 减(Unary minus)
        • 
+
      • ++ 自增1 （increment）
        • 
+
      • -- 自减1 （decrement）
        • 
+
      • ! 逻辑否 （Logical NOT ）
        • 
+
      • ~ 按位否 （Bitwise NOT ）
        • 
+
      • + 加（Unary plus）
        • 
+
      • - 减（Unary minus）
        • 
 
      
 
      对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
      
 
      作为对上面标准库运算符的补充，你也可以对 某个函数的参数使用 '&'运算符。 更多信息，请参见： "In-Out parameters".
      
@@ -617,16 +631,16 @@
 prefix-expression → in-out-expression­
 in-out-expression → &­identifier­
      
 
-
      二元表达式( Binary Expressions)
      
+
      二元表达式（Binary Expressions）
      
 
      二元表达式由 "左边参数" + "二元运算符" + "右边参数" 组成, 它有如下的形式：
      
 
        left-hand argument operator right-hand argument
      
 
      Swift 标准库提供了如下的二元运算符：
      
 
        
 
      • 求幂相关（无结合，优先级160）
          
-
        • << 按位左移(Bitwise left shift)
          • 
+
        • << 按位左移（Bitwise left shift）
          • 
 
        • 
 
          
-
          按位右移(Bitwise right shift)
          
+
          按位右移（Bitwise right shift）
          
 
          
 
          
 
          • 
@@ -636,32 +650,32 @@
 
        • * 乘
          • 
 
        • / 除
          • 
 
        • % 求余
          • 
-
        • &* 乘法，忽略溢出( Multiply, ignoring overflow)
          • 
-
        • &/ 除法，忽略溢出(Divide, ignoring overflow)
          • 
-
        • &% 求余, 忽略溢出( Remainder, ignoring overflow)
          • 
-
        • & 位与( Bitwise AND)
          • 
+
        • &* 乘法，忽略溢出（ Multiply, ignoring overflow）
          • 
+
        • &/ 除法，忽略溢出（Divide, ignoring overflow）
          • 
+
        • &% 求余, 忽略溢出（ Remainder, ignoring overflow）
          • 
+
        • & 位与（ Bitwise AND）
          • 
 
        
 
        • 
-
      • 加减法相关(左结合, 优先级140)
          
+
        • 加减法相关（左结合, 优先级140）
            
 
          • + 加
            • 
 
          • - 减
            • 
 
          • &+ Add with overflow
            • 
 
          • &- Subtract with overflow
            • 
-
          • | 按位或(Bitwise OR )
            • 
-
          • ^ 按位异或(Bitwise XOR)
            • 
+
          • | 按位或（Bitwise OR ）
            • 
+
          • ^ 按位异或（Bitwise XOR）
            • 
 
          
 
          • 
-
        • Range (无结合,优先级 135)
            
+
          • Range （无结合,优先级 135）
              
 
            • .. 半闭值域 Half-closed range
              • 
 
            • ... 全闭值域 Closed range
              • 
 
            
 
            • 
-
          • 类型转换 (无结合,优先级 132)
              
-
            • is 类型检查( type check)
              • 
-
            • as 类型转换( type cast)
              • 
+
            • 类型转换 （无结合,优先级 132）
                
+
              • is 类型检查（ type check）
                • 
+
              • as 类型转换（ type cast）
                • 
 
              
 
              • 
-
            • Comparative (无结合,优先级 130)
                
+
              • Comparative （无结合,优先级 130）
                  
 
                • < 小于
                  • 
 
                • <= 小于等于
                  • 
 
                • 
@@ -676,23 +690,23 @@
 
                • != 不等
                  • 
 
                • === 恒等于
                  • 
 
                • !== 不恒等
                  • 
-
                • ~= 模式匹配( Pattern match)
                  • 
+
                • ~= 模式匹配（ Pattern match）
                  • 
 
                
 
                • 
-
              • 合取( Conjunctive) (左结合,优先级 120)
                  
-
                • && 逻辑与(Logical AND)
                  • 
+
                • 合取（ Conjunctive） （左结合,优先级 120）
                    
+
                  • && 逻辑与（Logical AND）
                    • 
 
                  
 
                  • 
-
                • 析取(Disjunctive) (左结合,优先级 110)
                    
-
                  • || 逻辑或( Logical OR)
                    • 
+
                  • 析取（Disjunctive） （左结合,优先级 110）
                      
+
                    • || 逻辑或（ Logical OR）
                      • 
 
                    
 
                    • 
-
                  • 三元条件(Ternary Conditional )(右结合,优先级 100)
                      
+
                    • 三元条件（Ternary Conditional ）（右结合,优先级 100）
                        
 
                      • ?: 三元条件 Ternary conditional
                        • 
 
                      
 
                      • 
-
                    • 赋值 (Assignment) (右结合, 优先级 90)
                        
-
                      • = 赋值(Assign)
                        • 
+
                      • 赋值 （Assignment） （右结合, 优先级 90）
                          
+
                        • = 赋值（Assign）
                          • 
 
                        • *=  Multiply and assign
                          • 
 
                        • /= Divide and assign
                          • 
 
                        • %= Remainder and assign
                          • 
@@ -713,24 +727,24 @@
 
                        
 
                        • 
 
                      
-
                      关于这些运算符(operators)的更多信息，请参见：Basic Operators and Advanced Operators.
                      
+
                      关于这些运算符（operators）的更多信息，请参见：Basic Operators and Advanced Operators.
                      
 
                      
 
                      
 
                      注意
                      
-
                      在解析时,  一个二元表达式表示为一个一级数组(a flat list), 这个数组(List)根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3  5 首先被认为是：  2, + , 3, , 5. 随后它被转换成 tree (2 + (3 * 5))
                      
+
                      在解析时,  一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3  5 首先被认为是：  2, + , 3, , 5. 随后它被转换成 tree （2 + （3 * 5））
                      
 
                      
 
                      二元表达式的语法
                      
 
                      binary-expression → binary-operator­prefix-expression­
 binary-expression → assignment-operator­prefix-expression
 binary-expression → conditional-operator­prefix-expression
 binary-expression → type-casting-operator­
-binary-expressions → binary-expression­binary-expressions(opt­)
                      
+binary-expressions → binary-expression­binary-expressions(opt)
                      
 
                      
-
                      赋值表达式( Assignment Operator)
                      
+
                      赋值表达式（Assignment Operator）
                      
 
                      The assigment operator sets a new value for a given expression. It has the following form:
 赋值表达式会对某个给定的表达式赋值。 它有如下的形式；
                      
 
                      expression = value
                      
-
                      就是把右边的 value 赋值给左边的 expression. 如果左边的expression 需要接收多个参数（是一个tuple )，那么右边必须也是一个具有同样数量参数的tuple. (允许嵌套的tuple)
                      
+
                      就是把右边的 value 赋值给左边的 expression. 如果左边的expression 需要接收多个参数（是一个tuple ），那么右边必须也是一个具有同样数量参数的tuple. （允许嵌套的tuple）
                      
 
                      (a, _, (b, c)) = ("test", 9.45, (12, 3))
 // a is "test", b is 12, c is 3, and 9.45 is ignored
 
                      
@@ -739,27 +753,27 @@
 
                      赋值表达式的语法
                      
 
                      assignment-operator → =­
                      
 
-
                      三元条件运算符(Ternary Conditional Operator)
                      
+
                      三元条件运算符（Ternary Conditional Operator）
                      
 
                      三元条件运算符 是根据条件来获取值。 形式如下：
                      
 
                      `condition` ? `expression used if true` : `expression used if false`
-
                      如果 condition 是true, 那么返回 第一个表达式的值(此时不会调用第二个表达式）， 否则返回第二个表达式的值(此时不会调用第一个表达式）。
                      
+
      • 如果 condition 是true, 那么返回 第一个表达式的值（此时不会调用第二个表达式）， 否则返回第二个表达式的值（此时不会调用第一个表达式）。
      
 
      想看三元条件运算符的例子，请参见： Ternary Conditional Operator.
      
 
      
 
      三元条件表达式
      
 
      conditional-operator → ?­expression­:­
      
 
      
-
      类型转换运算符(Type-Casting Operators)
      
+
      类型转换运算符（Type-Casting Operators）
      
 
      有两种类型转换操作符： as 和 is.  它们有如下的形式：
      
 
      `expression` as `type`
 `expression` as? `type`
 `expression` is `type`
-
      as 运算符会把目标表达式转换成指定的类型(specified type)，过程如下：
      
+
      as 运算符会把目标表达式转换成指定的类型（specified type），过程如下：
      
 
        
-
      • 如果类型转换成功， 那么目标表达式就会返回指定类型的实例(instance). 例如：把子类(subclass)变成父类(superclass)时.
        
+
      • 如果类型转换成功， 那么目标表达式就会返回指定类型的实例（instance）. 例如：把子类（subclass）变成父类（superclass）时.
        
 
        • 
-
      • 如果转换失败，则会抛出编译错误( compile-time error)。
        
+
      • 如果转换失败，则会抛出编译错误（ compile-time error）。
        
 
        • 
-
      • 如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，) 那么目标表达式就会变成指定的类型的optional. (is an optional of the specified type ) 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.
        
+
      • 如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，） 那么目标表达式就会变成指定的类型的optional. （is an optional of the specified type ） 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.
        
 
        • 
 
      
 
      class SomeSuperType {}
@@ -775,9 +789,9 @@ let z = s as SomeChildType  // might fail at runtime; type is SomeChildType?
 
      let y1 = x as SomeType  // Type information from 'as'
 let y2: SomeType = x    // Type information from an annotation
 
      
-
      'is' 运算符在“运行时(runtime)”会做检查。 成功会返回true, 否则 false
      
+
      'is' 运算符在“运行时（runtime）”会做检查。 成功会返回true, 否则 false
      
 
      The check must not be known to be true or false at compile time. The following are invalid:
-上述检查在“编译时(compile time)”不能使用。 例如下面的使用是错误的：
      
+上述检查在“编译时（compile time）”不能使用。 例如下面的使用是错误的：
      
 
      "hello" is String
 "hello" is Int
 
      
@@ -786,11 +800,11 @@ let y2: SomeType = x    // Type information from an annotation
 
      类型转换的语法
      
 
      type-casting-operator → is­type­| as­?(opt)­type
      
 
-
      主要表达式(Primary Expressions)
      
+
      主要表达式（Primary Expressions）
      
 
      主要表达式是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。
      
 
      
 
      主要表达式的语法
      
-
      primary-expression → identifier­generic-argument-clause­(opt)
+
      primary-expression → identifier­generic-argument-clause(opt)
 primary-expression → literal-expression­
 primary-expression → self-expression­
 primary-expression → superclass-expression­
@@ -799,14 +813,14 @@ let y2: SomeType = x    // Type information from an annotation
 primary-expression → implicit-member-expression
 primary-expression → wildcard-expression
      
 
      
-
      字符型表达式(Literal Expression)
      
-
      由这些内容组成：普通的字符（string, number) , 一个字符的字典或者数组，或者下面列表中的特殊字符。
      
+
      字符型表达式（Literal Expression）
      
+
      由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。
      
 
-
-
-
+
+
+
@@ -832,13 +846,13 @@ let y2: SomeType = x    // Type information from an annotation
 
      
 
 
      字符(Literal)类型(Type)值(Value)字符（Literal）类型（Type）值（Value）
 
      
       
 
 
 
      
-
      在某个函数(function)中，__FUNCTION__ 会返回当前函数的名字。 在某个方法(method)中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员(member)中会返回这个keyword的名字，在某个文件的顶端(the top level of a file)，它返回的是当前module的名字。
      
+
      在某个函数（function）中，__FUNCTION__ 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员（member）中会返回这个keyword的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
      
 
      一个array literal，是一个有序的值的集合。 它的形式是：
      
 
      [`value 1`, `value 2`, `...`]
-
      数组中的最后一个表达式可以紧跟一个逗号(','). []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.(closest common supertype)
      
-
      一个dictionary literal 是一个包含无序的键值对(key-value pairs)的集合，它的形式是:
      
+
      数组中的最后一个表达式可以紧跟一个逗号（','）. []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.（closest common supertype）
      
+
      一个dictionary literal 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:
      
 
      [`key 1`: `value 1`, `key 2`: `value 2`, `...`]
-
      dictionary 的最后一个表达式可以是一个逗号(','). [:] 表示一个空的dictionary. 它的type是 Dictionary (这里KeyType表示 key的type, ValueType表示 value的type) 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type( closest common supertype).
      
+

      dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.

      字符型表达式的语法

      literal-expression → literal @@ -851,21 +865,21 @@ let y2: SomeType = x // Type information from an annotation dictionary-literal-items → dictionary-literal-item,­(opt)­| dictionary-literal-item­,­dictionary-literal-items­ dictionary-literal-item → expression­:­expression­

      -

      self表达式(Self Expression)

      +

      self表达式（Self Expression）

      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.

      -

      当访问 member（成员变量时）， self 用来区分重名变量(例如函数的参数). 例如， -(下面的 self.greeting 指的是 var greeting: String, 而不是 init(greeting: String) )

      +

      如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type.

      +

      当访问 member（成员变量时）， self 用来区分重名变量（例如函数的参数）. 例如， +（下面的 self.greeting 指的是 var greeting: String, 而不是 init（greeting: String） ）

      class SomeClass {
     var greeting: String
-    init(greeting: String) {
+    init（greeting: String） {
         self.greeting = greeting
     }
 }
@@ -873,8 +887,8 @@ self.init(initializer arguments)
      
 
      在mutating 方法中， 你可以使用self 对 该instance进行赋值。
      
 
      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）
     }
 }
 
      
@@ -885,13 +899,13 @@ self.init(initializer arguments)
      
 self-expression → self­[­expression­]­
 self-expression → self­.­init­
      
 
-
      超类表达式(Superclass Expression)
      
+
      超类表达式（Superclass Expression）
      
 
      超类表达式可以使我们在某个class中访问它的超类. 它有如下形式：
      
 
      super.`member name`
 super[`subscript index`]
-super.init(`initializer arguments`)
-
      形式1 用来访问超类的某个成员(member). 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.
      
-
      子类(subclass)可以通过超类(superclass)表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现(既有的方法或者逻辑)。
      
+super.init（`initializer arguments`）
+

      形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.

      +

      子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。

      GRAMMAR OF A SUPERCLASS EXPRESSION

      superclass-expression → superclass-method-expression | superclass-subscript-expression­| superclass-initializer-expression @@ -899,27 +913,27 @@ super.init(`initializer arguments`) superclass-subscript-expression → super­[­expression­]­ superclass-initializer-expression → super­.­init­

      -

      闭包表达式(Closure Expression)

      -

      闭包(closure) 表达式可以建立一个闭包(在其他语言中也叫 lambda, 或者 匿名函数(anonymous function)). 跟函数(function)的声明一样， 闭包(closure)包含了可执行的代码(跟方法主体(statement)类似） 以及接收(capture)的参数。 它的形式如下：

      -
        { (parameters) -> return type in
+
      闭包表达式（Closure Expression）
      
+
      闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下：
      
+
        { （parameters） -> return type in
       statements
   }
 
      
 
      闭包的参数声明形式跟方法中的声明一样, 请参见：Function Declaration.
      
 
      闭包还有几种特殊的形式, 让使用更加简洁：
      
 
        
-
      • 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知(inferred) ，那么就会抛出编译错误。
        • 
-
      • 闭包可以省略参数，转而在方法体(statement)中使用 $0, $1, $2 来引用出现的第一个，第二个，第三个参数。
        • 
+
      • 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知（inferred） ，那么就会抛出编译错误。
        • 
+
      • 闭包可以省略参数，转而在方法体（statement）中使用 $0, $1, $2 来引用出现的第一个，第二个，第三个参数。
        • 
 
      • 如果闭包中只包含了一个表达式，那么该表达式就会自动成为该闭包的返回值。 在执行 'type inference '时，该表达式也会返回。
        • 
 
      
 
      下面几个 闭包表达式是 等价的：
      
 
      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
 }
 
@@ -928,15 +942,15 @@ myFunction { return $0 + $1 }
 myFunction { $0 + $1 }
 
      
 
      关于 向闭包中传递参数的内容，参见： Function Call Expression.
      
-
      闭包表达式可以通过一个参数列表(capture list) 来显式指定它需要的参数。 参数列表 由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字(在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。
      
-
      在闭包的参数列表( capture list)中， 参数可以声明为 'weak' 或者 'unowned' .
      
-
      myFunction { print(self.title) }                    // strong capture
-myFunction { [weak self] in print(self!.title) }    // weak capture
-myFunction { [unowned self] in print(self.title) }  // unowned capture
+
      闭包表达式可以通过一个参数列表（capture list） 来显式指定它需要的参数。 参数列表 由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字（在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。
      
+
      在闭包的参数列表（ capture list）中， 参数可以声明为 'weak' 或者 'unowned' .
      
+
      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. ) 例如：
      
+
      在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（captured with the specified strength. ） 例如：
      
 
      // 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.
      
 
      
@@ -948,10 +962,10 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
 closure-signature →  capture-list­identifier-list­function-result­(opt)­in­
 closure-signature →  capture-list­in­
 capture-list → [­capture-specifier­expression­]­
-capture-specifier → weak­| unowned­| unowned(safe)­| unowned(unsafe)­
      
+capture-specifier → weak­| unowned­| unowned（safe）­| unowned（unsafe）­
      
 
      
-
      隐式成员表达式(Implicit Member Expression)
      
-
      在可以判断出类型(type)的上下文(context)中，隐式成员表达式是访问某个type的member( 例如 class method, enumeration case) 的简洁方法。 它的形式是：
      
+
      隐式成员表达式（Implicit Member Expression）
      
+
      在可以判断出类型（type）的上下文（context）中，隐式成员表达式是访问某个type的member（ 例如 class method, enumeration case） 的简洁方法。 它的形式是：
      
 
      .member name
      
 
      例子：
      
 
      var x = MyEnumeration.SomeValue
@@ -961,27 +975,27 @@ x = .AnotherValue
 
       隐式成员表达式的语法
      
 
       implicit-member-expression → .­identifier
      
 
-
      圆括号表达式(Parenthesized Expression)
      
+
      圆括号表达式（Parenthesized Expression）
      
 
      圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：
      
-
      (identifier 1: expression 1, identifier 2: expression 2, ...)
      
-
      圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： (1)的 type是Int, 而不是(Int)
      
+
      （identifier 1: expression 1, identifier 2: expression 2, ...）
      
+
      圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）
      
 
      
 
      圆括号表达式的语法
      
-
      parenthesized-expression → (­expression-element-list (opt)­)­
+
      parenthesized-expression → （­expression-element-list (opt)­）­
 expression-element-list → expression-element­| expression-element­,­expression-element-list­
 expression-element → expression­| identifier­:­expression
      
 
      
-
      通配符表达式( Wildcard Expression)
      
+
      通配符表达式（Wildcard Expression）
      
 
      通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。）
      
-
      (x, _) = (10, 20)
+
      （x, _） = （10, 20）
 // x is 10, 20 is ignored
 
      
 
      
 
      通配符表达式的语法
      
 
      wildcard-expression → _­
      
 
      
-
      后缀表达式( Postfix Expressions)
      
-
      后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式(primary expression)都是一个后缀表达式
      
+
      后缀表达式（Postfix Expressions）
      
+
      后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式（primary expression）都是一个后缀表达式
      
 
      Swift 标准库提供了下列后缀表达式：
      
 
        
 
      • ++ Increment
        • 
@@ -1001,21 +1015,21 @@ x = .AnotherValue
 postfix-expression → forced-value-expression­
 postfix-expression → optional-chaining-expression­
        
 
-
        函数调用表达式( Function Call Expression)
        
+
        函数调用表达式（Function Call Expression）
        
 
        函数调用表达式由函数名和参数列表组成。它的形式如下：
        
-
        function name(argument value 1, argument value 2)
        
+
        function name（argument value 1, argument value 2）
        
 
        The function name can be any expression whose value is of a function type.
-(不用翻译了, 太罗嗦）
        
+（不用翻译了, 太罗嗦）
        
 
        如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如：
        
-
        function name(argument name 1: argument value 1, argument name 2: argument value 2)
        
-
        可以在 函数调用表达式的尾部(最后一个参数之后)加上 一个闭包(closure) ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
        
+
        function name（argument name 1: argument value 1, argument name 2: argument value 2）
        
+
        可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（closure） ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
        
 
        // 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}
 
        
 
        如果闭包是该函数的唯一参数，那么圆括号可以省略。
        
 
        // someFunction takes a closure as its only argument
-myData.someMethod() {$0 == 13}
+myData.someMethod（） {$0 == 13}
 myData.someMethod {$0 == 13}
 
        
 
        
@@ -1024,21 +1038,21 @@ myData.someMethod {$0 == 13}
 function-call-expression → postfix-expression­parenthesized-expression­(opt)­trailing-closure­
 trailing-closure → closure-expression­
        
 
        
-
        初始化函数表达式(Initializer Expression)
        
+
        初始化函数表达式（Initializer Expression）
        
 
        Initializer表达式用来给某个Type初始化。 它的形式如下：
        
-
        expression.init(initializer arguments)
        
-
        (Initializer表达式用来给某个Type初始化。) 跟函数(function)不同， initializer 不能返回值。
        
+
        expression.init（initializer arguments）
        
+
        （Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。
        
 
        var x = SomeClass.someClassFunction // ok
 var y = SomeClass.init              // error
 ```swift
 
-可以通过 initializer 表达式来委托调用(delegate to )到superclass的initializers.
+可以通过 initializer 表达式来委托调用（delegate to ）到superclass的initializers.
 
 ```swift
 class SomeSubClass: SomeSuperClass {
-    init() {
+    init（） {
         // subclass initialization goes here
-        super.init()
+        super.init（）
     }
 }
 
        
@@ -1046,29 +1060,29 @@ class SomeSubClass: SomeSuperClass {
 
        initializer表达式的语法
        
 
        initializer-expression → postfix-expression­.­init­
        
 
-
        显式成员表达式(Explicit Member Expression)
        
+
        显式成员表达式（Explicit Member Expression）
        
 
        显示成员表达式允许我们访问type, tuple, module的成员变量。它的形式如下：
        
 
        expression.member name
        
-
        该member 就是某个type在声明时候所定义(declaration or extension) 的变量, 例如：
        
+
        该member 就是某个type在声明时候所定义（declaration or extension） 的变量, 例如：
        
 
        class SomeClass {
     var someProperty = 42
 }
-let c = SomeClass()
+let c = SomeClass（）
 let y = c.someProperty  // Member access
 
        
-
        对于tuple, 要根据它们出现的顺序(0, 1, 2...)来使用:
        
-
        var t = (10, 20, 30)
+
        对于tuple, 要根据它们出现的顺序（0, 1, 2...）来使用:
        
+
        var t = （10, 20, 30）
 t.0 = t.1
-// Now t is (20, 20, 30)
+// 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.）
        
 
        
 
        显示成员表达式的语法
        
 
        explicit-member-expression → postfix-expression­.­decimal-digit­
 explicit-member-expression → postfix-expression­.­identifier­generic-argument-clause(opt)
        
 
        
-
        后缀self表达式(Postfix Self Expression)
        
+
        后缀self表达式（Postfix Self Expression）
        
 
        后缀表达式由 某个表达式 + '.self' 组成. 形式如下：
        
 
        expression.self
 type.self
        
@@ -1078,61 +1092,61 @@ t.0 = t.1
 
        后缀self表达式的语法
        
 
        postfix-self-expression → postfix-expression­.­self­
        
 
-
        dynamic表达式(Dynamic Type Expression)
        
-
        (因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression)
        
+
        dynamic表达式（Dynamic Type Expression）
        
+
        （因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression）
        
 
        dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。
        
 
        expression.dynamicType
        
-
        上面的形式中， expression 不能是某type的名字(当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子：
        
+
        上面的形式中， expression 不能是某type的名字（当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子：
        
 
        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"
 
        
 
        
 
        dynamic type 表达式
        
 
        dynamic-type-expression → postfix-expression­.­dynamicType­
        
 
        
-
        下标表达式( Subscript Expression)
        
-
        下标表达式提供了通过下标访问getter/setter 的方法。它的形式是：
        
+
        附属脚本表达式（Subscript Expression）
        
+
        附属脚本表达式提供了通过附属脚本访问getter/setter 的方法。它的形式是：
        
 
        expression[index expressions]
        
-
        可以通过下标表达式通过getter获取某个值，或者通过setter赋予某个值.
        
+
        可以通过附属脚本表达式通过getter获取某个值，或者通过setter赋予某个值.
        
 
        关于subscript的声明，请参见： Protocol Subscript Declaration.
        
 
        
-
        下标表达式的语法
        
+
        附属脚本表达式的语法
        
 
        subscript-expression → postfix-expression­[­expression-list­]­
        
 
        
-
        强制取值表达式(Forced-Value Expression)
        
-
        强制取值表达式用来获取某个目标表达式的值(该目标表达式的值必须不是nil )。它的形式如下：
        
+
        强制取值表达式（Forced-Value Expression）
        
+
        强制取值表达式用来获取某个目标表达式的值（该目标表达式的值必须不是nil ）。它的形式如下：
        
 
        expression!
        
-
        如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误(runtime error)。
        
+
        如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误（runtime error）。
        
 
        
 
        强制取值表达式的语法
        
 
        forced-value-expression → postfix-expression­!­
        
 
        
-
        可选链表达式(Optional-Chaining Expression)
        
+
        可选链表达式（Optional-Chaining Expression）
        
 
        可选链表达式由目标表达式 + '?' 组成，形式如下：
        
 
        expression?
        
 
        后缀'?' 返回目标表达式的值，把它做为可选的参数传递给后续的表达式
        
-
        如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值(依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type(In either case, the value of the postfix expression is still of an optional type)
        
-
        如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction() 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction()方法。 然后对于 "c?.property.performAction()" 这个整体，它的返回值是一个optional type.
        
+
        如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值（依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type（In either case, the value of the postfix expression is still of an optional type）
        
+
        如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction（） 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction（）方法。 然后对于 "c?.property.performAction（）" 这个整体，它的返回值是一个optional type.
        
 
        var c: SomeClass?
-var result: Bool? = c?.property.performAction()
+var result: Bool? = c?.property.performAction（）
 
        
 
        如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价：
        
 
        if let unwrappedC = c {
-    result = unwrappedC.property.performAction()
+    result = unwrappedC.property.performAction（）
 }
 
        
 
        
@@ -1184,6 +1198,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/05_Declarations.html b/chapter3/05_Declarations.html
index b93ae937..b896b4cf 100644
--- a/chapter3/05_Declarations.html
+++ b/chapter3/05_Declarations.html
@@ -5,12 +5,12 @@
         
         
         
-        声明 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,6 +587,667 @@
 
                 
        
                 
+                    
        
+                    
+                        
        
+
        翻译：marsprince
        
+
        校对：numbbbbb
        
+
        
+
        声明
        
+
        
+
        本页包含内容：
        
+
+
        一条声明可以在你的程序里引入新的名字和构造。举例来说，你可以使用声明来引入函数和方法，变量和常量，或者来定义
+新的命名好的枚举，结构，类和协议类型。你也可以使用一条声明来延长一个已经存在的命名好的类型的行为。或者在你的
+程序里引入在其他地方声明的符号。
        
+
        在swift中，大多数声明在某种意义上讲也是执行或同事声明它们的初始化定义。这意味着，因为协议和他们的成员不匹配，
+大多数协议成员需要单独的声明。为了方便起见，也因为这些区别在swift里不是很重要，声明语句同时包含了声明和定义。
        
+
        
+
        GRAMMAR OF A DECLARATION
        
+
        declaration → import-declaration­
        
+
        declaration → constant-declaration­
        
+
        declaration → variable-declaration­
        
+
        declaration → typealias-declaration­
        
+
        declaration → function-declaration­
        
+
        declaration → enum-declaration­
        
+
        declaration → struct-declaration­
        
+
        declaration → class-declaration­
        
+
        declaration → protocol-declaration­
        
+
        declaration → initializer-declaration­
        
+
        declaration → deinitializer-declaration­
        
+
        declaration → extension-declaration­
        
+
        declaration → subscript-declaration­
        
+
        declaration → operator-declaration­
        
+
        declarations → declaration­declarations­opt­
        
+
        declaration-specifiers → declaration-specifier­declaration-specifiers­opt­
        
+
        declaration-specifier → class­ | mutating ­| nonmutating­ | override­ | static­ | unowned |
        
+
        
+
        
+
        模块范围
        
+
        模块范围定义了对模块中其他源文件可见的代码。（注：待改进）在swift的源文件中，最高级别的代码由零个或多个语句，
+声明和表达组成。变量，常量和其他的声明语句在一个源文件的最顶级被声明，使得他们对同一模块中的每个源文件都是可见的。
        
+
        
+
        GRAMMAR OF A TOP-LEVEL DECLARATION
        
+
        top-level-declaration → statements ­opt
        
+
        
+
        
+
        代码块
        
+
        代码块用来将一些声明和控制结构的语句组织在一起。它有如下的形式：
        
+
        {
+    `statements`
+}
+
        代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。
        
+
        
+
        GRAMMAR OF A CODE BLOCK
        
+
        code-block → ­statements ­opt­
        
+
        
+
        
+
        引入声明
        
+
        引入声明使你可以使用在其他文件中声明的内容。引入语句的基本形式是引入整个代码模块；它由import关键字开始，后面
+紧跟一个模块名：
        
+
        import  module
+
        你可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
+当你使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。
        
+
        import import kind module.symbol name
+import module.submodule
+
        
+
        GRAMMAR OF AN IMPORT DECLARATION
        
+
        import-declaration → attributes ­opt ­import­ import-kind­ opt import-path­
+import-kind → typealias­ | struct­ | class­ | enum­ | protocol­ | var­ | func­
+import-path → import-path-identifier­  import-path-identifier­.­import-path­
+import-path-identifier → identifier­  operator
        
+
        
+
        
+
        常量声明
        
+
        常量声明可以在你的程序里命名一个常量。常量以关键词let来声明，遵循如下的格式:
        
+
        let constant name: type = expression
+
        当常量的值被给定后，常量就将常量名称和表达式初始值不变的结合在了一起，而且不能更改。
+这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
+当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，他被认为是一个常量
+属性。常量并不是可计算的属性，因此不包含getters和setters。（译者注：getters和setters不知道怎么翻译，待改进）
        
+
        如果常量名是一个元祖形式，元祖中的每一项初始化表达式中都要有对应的值
        
+
        let (firstNumber, secondNumber) = (10, 42)
+
        在上例中，firstNumber是一个值为10的常量，secnodeName是一个值为42的常量。所有常量都可以独立的使用：
        
+
        1  println("The first number is \(firstNumber).")
+2  // prints "The first number is 10."
+3  println("The second number is \(secondNumber).")
+4  // prints "The second number is 42."
+
        类型注释（:type）在常量声明中是一个可选项，它可以用来描述在类型接口（type inference）中找到的类型。
        
+
        声明一个静态常量要使用关键字static。静态属性在类型属性（type propetries）中有介绍。
        
+
        如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看常量和变量（constants and variables）,
+存储属性（stored properties）等节。
        
+
        
+
        GRAMMAR OF A CONSTANT DECLARATION
        
+
        constant-declaration → attributes­ opt ­declaration-specifiers­ opt ­let­pattern-initializer-list­
+pattern-initializer-list → pattern-initializer­ | pattern-initializer­ , pattern-initializer-list­
+pattern-initializer → pattern ­initializer ­opt­
+initializer → =­expression
        
+
        
+
        
+
        变量声明
        
+
        变量声明可以在你的程序里声明一个变量，它以关键字var来声明。根据声明变量类型和值的不同，如存储和计算
+变量和属性，存储变量和属性监视，和静态变量属性，有着不同的声明形式。（待改进）
+所使用的声明形式取决于变量所声明的范围和你打算声明的变量类型。
        
+
        
+
        注意：
        
+
        你也可以在协议声明的上下文声明属性，详情参见类型属性声明。
        
+
        
+
        存储型变量和存储型属性
        
+
        下面的形式声明了一个存储型变量或存储型变量属性
        
+
        var variable name: type = expression
+
        你可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
+在全局或者一个函数内被声明时，它代表一个存储型变量。当他在类或者结构体中被声明时，他代表一个存储型变量属性。
        
+
        构造器表达式可以被
        
+
        和常量声明相比，如果变量名是一个元祖类型，元祖的每一项的名字都要和初始化表达式一致。
        
+
        正如名字一样，存储型变量的值或存储型变量属性存储在内存中。
        
+
        计算型变量和计算型属性
        
+
        如下形式声明一个一个存储型变量或存储型属性：
        
+
        var variable name: type {
+get {
+    statements
+}
+set(setter name) {
+    statements
+}
+}
+
        你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
+当变量以这种形式在全局或者一个函数内被声明时，它代表一个计算型变量。当他在类，结构体，枚举，扩展声明的上下文
+中中被声明时，他代表一个计算型变量属性。
        
+
        getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，你可以将这些语句
+都省略，只是简单的直接返回请求值，正如在只读计算属性(read-only computed properites)中描述的那样。
+但是如果你提供了一个setter语句，你也必需提供一个getter语句。
        
+
        setter的名字和圆括号内的语句是可选的。如果你写了一个setter名，它就会作为setter的参数被使用。如果你不写setter名，
+setter的初始名为newValue，正如在seter声明速记(shorthand setter declaration)中提到的那样。
        
+
        不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。
        
+
        获得更多信息，查看更多关于计算型属性的例子，请查看计算型属性(computed properties)一节。
        
+
        存储型变量监视器和属性监视器
        
+
        你可以用willset和didset监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明：
        
+
        var variable name: type = expression {
+willSet(setter name) {
+    statements
+}
+didSet(setter name {
+    statements
+}
+}
+
        你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
+当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个存储型变量监视器；
+当他在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表属性监视器。
        
+
        你可以为适合的监视器添加任何存储型属性。你也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性
+(无论是存储型还是计算型的)，参见重写属性监视器(overriding properyt observers)。
        
+
        初始化表达式在类或者结构体的声明中是可选的，但是在其他地方是必需的。无论在什么地方声明，
+所有包含监视器的变量声明都必须有类型注释(type annotation)。
        
+
        当变量或属性的值被改变时，willset和didset监视器提供了一个监视方法（适当的回应）。
+监视器不会在变量或属性第一次初始化时不会被运行，他们只有在值被外部初始化语句改变时才会被运行。
        
+
        willset监视器只有在变量或属性值被改变之前运行。新的值作为一个常量经过过willset监视器，因此不可以在
+willset语句中改变它。didset监视器在变量或属性值被改变后立即运行。和willset监视器相反，为了以防止你仍然
+需要获得旧的数据，旧变量值或者属性会经过didset监视器。这意味着，如果你在变量或属性自身的didiset监视器语句
+中设置了一个值，你设置的新值会取代刚刚在willset监视器中经过的那个值。
        
+
        在willset和didset语句中，setter名和圆括号的语句是可选的。如果你写了一个setter名，它就会作为willset和didset的参数被使用。如果你不写setter名，
+willset监视器初始名为newvalue，didset监视器初始名为oldvalue。
        
+
        当你提供一个willset语句时，didset语句是可选的。同样的，在你提供了一个didset语句时，willset语句是可选的。
        
+
        获得更多信息，查看如何使用属性监视器的例子，请查看属性监视器(prpperty observers)一节。
        
+
        类和静态变量属性
        
+
        class关键字用来声明类的计算型属性。static关键字用来声明类的静态变量属性。类和静态变量在类型属性(type properties)中有详细讨论。
        
+
        
+
        GRAMMAR OF A VARIABLE DECLARATION
        
+
        variable-declaration → variable-declaration-head­pattern-initializer-list­
        
+
        variable-declaration → variable-declaration-head ­variable-name ­type-annotation ­code-block­
        
+
        variable-declaration → variable-declaration-head ­variable-name ­type-annotation ­getter-setter-block­
        
+
        variable-declaration → variable-declaration-head ­variable-name­ type-annotation ­getter-setter-keyword-block­
        
+
        variable-declaration → variable-declaration-head­ variable-name ­type-annotation­initializer­ opt ­willSet-didSet-block­
        
+
        variable-declaration-head → attributes ­opt­ declaration-specifiers ­opt ­var
+­
+variable-name → identifier­
        
+
        getter-setter-block → {­getter-clause ­setter-clause­ opt­}­
        
+
        getter-setter-block → {­setter-clause ­getter-clause­}­
        
+
        getter-clause → attributes ­opt­get­code-block­
        
+
        setter-clause → attributes ­opt ­set­ setter-name­ opt­ code-block­
        
+
        setter-name → (­identifier­)­
        
+
        getter-setter-keyword-block → {­getter-keyword-clause ­setter-keyword-clause­ opt­}
+­
+getter-setter-keyword-block → {­setter-keyword-clause ­getter-keyword-clause­}
        
+
        getter-keyword-clause → attributes­ opt­ get­
        
+
        setter-keyword-clause → attributes ­opt­ set­
        
+
        willSet-didSet-block → {­willSet-clause ­didSet-clause ­opt­}­
        
+
        willSet-didSet-block → {­didSet-clause ­willSet-clause­}­
        
+
        willSet-clause → attributes ­opt ­willSet ­setter-name­ opt ­code-block­
        
+
        didSet-clause → attributes ­opt ­didSet ­setter-name ­opt­ code-block­
        
+
        
+
        
+
        类型的别名声明
        
+
        类型别名的声明可以在你的程序里为一个已存在的类型声明一个别名。类型的别名声明以关键字typealias开始，遵循如下的
+形式：
        
+
        typealias name = existing type
+
        当一个类型被别名被声明后，你可以在你程序的任何地方使用别名来代替已存在的类型。已存在的类型可以是已经被命名的
+类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
        
+
        查看更多Protocol Associated Type Declaration.
        
+
        
+
        GRAMMAR OF A TYPE ALIAS DECLARATION
        
+
        typealias-declaration → typealias-head­ typealias-assignment
+typealias-head → typealias­ typealias-name
+typealias-name → identifier
+typealias-assignment → =type
        
+
        
+
        
+
        函数声明
        
+
        你可以使用函数声明在你的程序里引入新的函数。函数可以在类的上下文，结构体，枚举，或者作为方法的协议中被声明。
+函数声明使用关键字func，遵循如下的形式：
        
+
        func function name(parameters) -> return type {
+    statements
+}
+
        如果函数不返回任何值，返回类型可以被忽略，如下所示：
        
+
        func function name(parameters) {
+    statements
+}
+
        每个参数的类型都要标明，它们不能被推断出来。初始时函数的参数是常值。在这些参数前面添加var使它们成为变量，
+作用域内任何对变量的改变只在函数体内有效，或者用inout使的这些改变可以在调用域内生效。
+更多关于in-out参数的讨论，参见in-out参数(in-out parameters)
        
+
        函数可以使用元组类型作为返回值来返回多个变量。
        
+
        函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于nested函数的讨论，参见nestde functions。
        
+
        参数名
        
+
        函数的参数是一个以逗号分隔的列表 。函数调用是的变量顺序必须和函数声明时的参数顺序一致。
+最简单的参数列表有着如下的形式：
        
+
        parameter name: parameter type
+
        对于函数参数来讲，参数名在函数体内被使用，而不是在函数调用时使用。对于方法参数，参数名在函数体内被使用，
+同时也在方法被调用时作为标签被使用。该方法的第一个参数名仅仅在函数体内被使用，就像函数的参数一样，举例来讲：
        
+
        func f(x: Int, y: String) -> String {
+    return y + String(x)
+}
+f(7, "hello")  // x and y have no name
+
+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
+#parameter name: parameter type
+_ local parameter name: parameter type
+
        在本地参数前命名的第二名称(second name)使得参数有一个扩展名。且不同于本地的参数名。
+扩展参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有扩展名 。
        
+
        在参数名前所写的哈希符号(#)代表着这个参数名可以同时作为外部或本体参数名来使用。等同于书写两次本地参数名。
+在函数或方法调用时，与其对应的语句必须包含这个名字。
        
+
        本地参数名前的强调字符(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
        
+
        特殊类型的参数
        
+
        参数可以被忽略，值可以是变化的，并且提供一个初始值，这种方法有着如下的形式：
        
+
        _ : <#parameter type#.
+parameter name: parameter type...
+parameter name: parameter type = default argument value
+
        以强调符(_)命名的参数明确的在函数体内不能被访问。
        
+
        一个以基础类型名的参数，如果紧跟着三个点(...)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，
+且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数int...被看做是int[]。
+查看可变参数的使用例子，详见可变参数(variadic parameters)一节。
        
+
        在参数的类型后面有一个以等号(=)连接的表达式，这样的参数被看做有着给定表达式的初试值。如果参数在函数
+调用时被省略了，就会使用初始值。如果参数没有胜率，那么它在函数调用是必须有自己的名字.举例来讲，
+f()和f(x:7)都是只有一个变量x的函数的有效调用，但是f(7)是非法的，因为它提供了一个值而不是名称。
        
+
        特殊方法
        
+
        以self修饰的枚举或结构体方法必须以mutating关键字作为函数声明头。
        
+
        子类重写的方法必须以override关键字作为函数声明头。不用override关键字重写的方法，使用了override关键字
+却并没有重写父类方法都会报错。
        
+
        和类型相关而不是和类型实例相关的方法必须在static声明的结构以或枚举内，亦或是以class关键字定义的类内。
        
+
        柯里化函数和方法
        
+
        柯里化函数或方法有着如下的形式：
        
+
        func function name(parameters)(parameters) -> return type {
+    statements
+}
+
        以这种形式定义的函数的返回值是另一个函数。举例来说，下面的两个声明时等价的:
        
+
        func addTwoNumbers(a: Int)(b: Int) -> Int {
+    return a + b
+}
+func addTwoNumbers(a: Int) -> (Int -> Int) {
+    func addTheSecondNumber(b: Int) -> Int {
+        return a + b
+    }
+    return addTheSecondNumber
+}
+
+addTwoNumbers(4)(5) // Returns 9
+
        多级柯里化应用如下
        
+
        
+
        GRAMMAR OF A FUNCTION DECLARATION
        
+
        function-declaration → function-head­ function-name­ generic-parameter-clause ­opt­function-signature­ function-body­
+function-head → attributes ­opt ­declaration-specifiers ­opt ­func­
+function-name → identifier­  operator­
+function-signature → parameter-clauses ­function-result ­opt­
+function-result → ->­attributes ­opt ­type­
+ function-body → code-block­
+ parameter-clauses → parameter-clause ­parameter-clauses ­opt­
+ parameter-clause → (­)­  (­parameter-list­...­opt­)­
+ parameter-list → parameter­  parameter­,­parameter-list­
+parameter → inout ­opt ­let ­opt­#­opt­parameter-name local-parameter-name ­opt­ type-annotation ­default-argument-clause ­opt­
+parameter → inout­opt­var­#­opt­parameter-name­local-parameter-name ­opt­ type-annotation­default-argument-clause ­opt­
+parameter → attributes ­opt ­type­
+parameter-name → identifier­  ­
+ local-parameter-name → identifier­  ­
+ default-argument-clause → =­expression­：
        
+
        
+
        
+
        枚举声明
        
+
        在你的程序里使用枚举声明来引入一个枚举类型。
        
+
        枚举声明有两种基本的形式，使用关键字enum来声明。枚举声明体使用从零开始的变量——叫做枚举事件，和任意数量的
+声明，包括计算型属性，实例方法，静态方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能
+包含析构器或者协议声明。
        
+
        不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他
+构造器，但是构造过程仅当构造器将一个枚举时间完成后才全部完成。
        
+
        和结构体类似但是和类不同，枚举是值类型：枚举实例在赋予变量或常量时，或者被函数调用时被复制。
+更多关于值类型的信息，参见结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
        
+
        你可以扩展枚举类型，正如在扩展名声明(Extension Declaration)中讨论的一样。
        
+
        任意事件类型的枚举
        
+
        如下的形式声明了一个包含任意类型枚举时间的枚举变量
        
+
        enum enumeration name {
+    case enumeration case 1
+    case enumeration case 2(associated value types)
+}
+
        这种形式的枚举声明在其他语言中有时被叫做可识别联合(discrinminated)。
        
+
        这种形式中，每一个事件块由关键字case开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是
+独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在关联值类型的元祖里被指定，立即书写在事件
+名后。获得更多关于关联值类型的信息和例子，请查看关联值(associated values)一节。
        
+
        使用原始事件值的枚举
        
+
        以下的形式声明了一个包含相同基础类型的枚举事件的枚举：
        
+
        enum enumeration name: raw value type {
+    case enumeration case 1 = raw value 1
+    case enumeration case 2 = raw value 2
+}
+
        在这种形式中，每一个事件块由case关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举
+事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做原始值(raw value)。这些值的类型在原始值类型(raw value type)
+中被指定，必须是字面上的整数，浮点数，字符或者字符串。
        
+
        每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为int，则不必为事件显式的指定值，
+它们会隐式的被标为值0,1,2等。每一个没有被赋值的Int类型时间会隐式的赋予一个初始值，它们是自动递增的。
        
+
        num ExampleEnum: Int {
+    case A, B, C = 5, D
+}
+
        在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是。因为ExampleEnum.C的值被显式的设定为5，因此
+ExampleEnum.D的值会自动增长为6.
        
+
        枚举事件的初始值可以调用方法roRaw获得，如ExampleEnum.B.toRaw()。你也可以通过调用fromRaw方法来使用初始值找到
+其对应的事件，并返回一个可选的事件。查看更多信息和获取初始值类型事件的信息，参阅初始值(raw values)。
        
+
        获得枚举事件
        
+
        使用点(.)来引用枚举类型的事件，如 EnumerationType.EnumerationCase。当枚举类型可以上下文推断出时，你可以
+省略它(.仍然需要)，参照枚举语法(Enumeration Syntax)和显式成员表达(Implicit Member Expression).
        
+
        使用switch语句来检验枚举事件的值，正如使用switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)一节描述的那样。
        
+
        枚举类型是模式匹配(pattern-matched)的，和其相反的是switch语句case块中枚举事件匹配，在枚举事件类型(Enumeration Case Pattern)中有描述。
        
+
        
+
        GRAMMAR OF AN ENUMERATION DECLARATION
        
+
          enum-declaration → attributes­opt­union-style-enum­  attributes­opt­raw-value-style-enum­
+   union-style-enum → enum-name­generic-parameter-clause­opt­{­union-style-enum-members­opt­}­
+    union-style-enum-members → union-style-enum-member­union-style-enum-members­opt­
+    union-style-enum-member → declaration­  union-style-enum-case-clause­
+    union-style-enum-case-clause → attributes­opt­case­union-style-enum-case-list­
+    union-style-enum-case-list → union-style-enum-case­  union-style-enum-case­,­union-style-enum-case-list­
+    union-style-enum-case → enum-case-name­tuple-type­opt­
+    enum-name → identifier­
+    enum-case-name → identifier­
+    raw-value-style-enum → enum-name­generic-parameter-clause­opt­:­type-identifier­{­raw-value-style-enum-members­opt­}­
+    raw-value-style-enum-members → raw-value-style-enum-member­raw-value-style-enum-members­opt­
+    raw-value-style-enum-member → declaration­  raw-value-style-enum-case-clause­
+    raw-value-style-enum-case-clause → attributes­opt­case­raw-value-style-enum-case-list­
+    raw-value-style-enum-case-list → raw-value-style-enum-case­  raw-value-style-enum-case­,­raw-value-style-enum-case-list­
+    raw-value-style-enum-case → enum-case-name­raw-value-assignment­opt­
+    raw-value-assignment → =­literal­
        
+
        
+
        
+
        结构体声明
        
+
        使用结构体声明可以在你的程序里引入一个结构体类型。结构体声明使用struct关键字，遵循如下的形式：
        
+
        struct structure name: adopted protocols {
+    declarations
+}
+
        结构体内包含零或多个声明。这些声明可以包括存储型和计算型属性，静态属性，实例方法，静态方法，构造器，
+类型别名，甚至其他结构体，类，和枚举声明。结构体声明不能包含析构器或者协议声明。详细讨论和包含多种结构体
+声明的实例，参见类和结构体一节。
        
+
        结构体可以包含任意数量的协议，但是不能继承自类，枚举或者其他结构体。
        
+
        有三种方法可以创建一个声明过的结构体实例：
        
+
        -调用结构体内声明的构造器，参照构造器(initializers)一节。
        
+
        —如果没有声明构造器，调用结构体的逐个构造器，详情参见Memberwise Initializers for Structure Types.
        
+
        —如果没有声明析构器，结构体的所有属性都有初始值，调用结构体的默认构造器，详情参见默认构造器(Default Initializers).
        
+
        结构体的构造过程参见初始化(initiaization)一节。
        
+
        结构体实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
        
+
        结构体是值类型；结构体的实例在被赋予变量或常量，被函数调用时被复制。获得关于值类型更多信息，参见
+结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
        
+
        你可以使用扩展声明来扩展结构体类型的行为，参见扩展声明(Extension Declaration).
        
+
        
+
        GRAMMAR OF A STRUCTURE DECLARATION
        
+
           struct-declaration → attributes­opt­struct­struct-name­generic-parameter-clause­opt­type-inheritance-clause­opt­struct-body­
+   struct-name → identifier­
+   struct-body → {­declarations­opt­}
        
+
        
+
        
+
        类声明
        
+
        你可以在你的程序中使用类声明来引入一个类。类声明使用关键字class，遵循如下的形式：
        
+
        class class name: superclass, adopted protocols {
+    declarations
+}
+
        一个类内包含零或多个声明。这些声明可以包括存储型和计算型属性，实例方法，类方法，构造器，单独的析构器方法，
+类型别名，甚至其他结构体，类，和枚举声明。类声明不能包含协议声明。详细讨论和包含多种类声明的实例，参见类和
+结构体一节。
        
+
        一个类只能继承一个父类，超类，但是可以包含任意数量的协议。这些超类第一次在type-inheritance-clause出现，遵循任意协议。
        
+
        正如在初始化声明(Initializer Declaration)谈及的那样，类可以有指定和方便的构造器。当你声明任一中构造器时，
+你可以使用requierd变量来标记构造器，要求任意子类来重写它。指定类的构造器必须初始化类所有的已声明的属性，
+它必须在子类构造器调用前被执行。
        
+
        类可以重写属性，方法和它的超类的构造器。重写的方法和属性必须以override标注。
        
+
        虽然超类的属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。这意味着，如果当前类重写了超类
+的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
        
+
        有两种方法来创建已声明的类的实例：
        
+
        -调用类的一个构造器，参见构造器(initializers)。
        
+
        -如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见默认构造器(default initializers).
        
+
        类实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
        
+
        类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，
+结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
        
+
        你可以使用扩展声明来扩展类的行为，参见扩展声明(Extension Declaration).
        
+
        
+
         GRAMMAR OF A CLASS DECLARATION
        
+
          class-declaration → attributes­opt­class­class-name­generic-parameter-clause­opt­type-inheritance-clause­opt­class-body­
+  class-name → identifier­
+ class-body → {­declarations­opt­}
        
+
        
+
        
+
        协议声明(translated by 小一)
        
+
        一个协议声明为你的程序引入一个命名了的协议类型。协议声明使用 protocol 关键词来进行声明并有下面这样的形式：
        
+
        protocol protocol name: inherited protocols {
+    protocol member declarations
+}
+
        
+
        协议的主体包含零或多个协议成员声明，这些成员描述了任何采用该协议必须满足的一致性要求。特别的，一个协议可以声明必须实现某些属性、方法、初始化程序及附属脚本的一致性类型。协议也可以声明专用种类的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议成员声明会在下面的详情里进行讨论。
        
+
        协议类型可以从很多其它协议那继承。当一个协议类型从其它协议那继承的时候，来自其它协议的所有要求就集合了，而且从当前协议继承的任何类型必须符合所有的这些要求。对于如何使用协议继承的例子，查看协议继承
        
+
        
+
        注意：
        
+
        你也可以使用协议合成类型集合多个协议的一致性要求，详情参见协议合成类型和协议合成
        
+
        
+
        你可以通过采用在类型的扩展声明中的协议来为之前声明的类型添加协议一致性。在扩展中你必须实现所有采用协议的要求。如果该类型已经实现了所有的要求，你可以让这个扩展声明的主题留空。
        
+
        默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和附属脚本。也就是说，你可以用optional属性标注这些协议成员声明以指定它们的一致性类型实现是可选的。optional属性仅仅可以用于使用objc属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用optional属性的信息及如何访问可选协议成员的指导——比如当你不能肯定是否一致性的类型实现了它们——参见可选协议要求
        
+
        为了限制协议的采用仅仅针对类类型，需要使用class_protocol属性标记整个协议声明。任意继承自标记有class_protocol属性协议的协议都可以智能地仅能被类类型采用。
        
+
        
+
        注意：
        
+
        如果协议已经用object属性标记了，class_protocol属性就隐性地应用于该协议；没有必要再明确地使用class_protocol属性来标记该协议了。
        
+
        
+
        协议是命名的类型，因此它们可以以另一个命名类型出现在你代码的所有地方，就像协议类型里讨论的那样。然而你不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
        
+
        你可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像委托(代理)模式描述的那样。
        
+
        
+
        协议声明的语法
+protocol-declaration → attributes­opt­protocol­protocol-name­type-inheritance-clause­opt­protocol-body­
+protocol-name → identifier­
+protocol-body → {­protocol-member-declarations­opt­}­
+protocol-member-declaration → protocol-property-declaration­
+protocol-member-declaration → protocol-method-declaration­
+protocol-member-declaration → protocol-initializer-declaration­
+protocol-member-declaration → protocol-subscript-declaration­
+protocol-member-declaration → protocol-associated-type-declaration­
+protocol-member-declarations → protocol-member-declaration­protocol-member-declarations­opt­
        
+
        
+
        
+
        协议属性声明
        
+
        协议声明了一致性类型必须在协议声明的主体里通过引入一个协议属性声明来实现一个属性。协议属性声明有一种特殊的类型声明形式：
        
+
        var property name: type { get set }
+
        
+
        同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了getter和setter要求。结果就是你不需要在协议里它被声明的地方实现getter和setter。
        
+
        getter和setter要求可以通过一致性类型以各种方式满足。如果属性声明包含get和set关键词，一致性类型就可以用可读写（实现了getter和setter）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含get关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见属性要求
        
+
        更多参见变量声明
        
+
        
+
        协议属性声明语法
+protocol-property-declaration → variable-declaration-head­variable-name­type-annotation­getter-setter-keyword-block­
        
+
        
+
        协议方法声明
        
+
        协议声明了一致性类型必须在协议声明的主体里通过引入一个协议方法声明来实现一个方法.
+协议方法声明和函数方法声明有着相同的形式，包含如下两条规则：他们不包括函数体，你不能在类的声明内为他们的
+参数提供初始值.举例来说，符合的类型执行协议必需的方法。参见必需方法一节。
        
+
        使用关键字class可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类也用关键字class声明。
+相反的，执行这些方法的结构体必须以关键字static声明。如果你想使用扩展方法，在扩展类时使用class关键字，
+在扩展结构体时使用static关键字。
        
+
        更多请参阅函数声明。
        
+
        
+
        GRAMMAR OF A PROTOCOL METHOD DECLARATION
        
+
        protocol-method-declaration → function-head­function-name­generic-parameter-clause­opt­function-signature­
        
+
        
+
        协议构造器声明
        
+
        协议声明了一致性类型必须在协议声明的主体里通过引入一个协议构造器声明来实现一个构造器。协议构造器声明
+除了不包含构造器体外，和构造器声明有着相同的形式，
        
+
        更多请参阅构造器声明。
        
+
        
+
        GRAMMAR OF A PROTOCOL INITIALIZER DECLARATION
        
+
        protocol-initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­
        
+
        
+
        协议附属脚本声明
        
+
        协议声明了一致性类型必须在协议声明的主体里通过引入一个协议附属脚本声明来实现一个附属脚本。协议属性声明
+对附属脚本声明有一个特殊的形式：
        
+
        
+
        subscript (parameters) -> return type { get set }
        
+
        
+
        附属脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果附属脚本申明包含get和set关键字，
+一致的类型也必须有一个getter和setter语句。如果附属脚本声明值包含get关键字，一致的类型必须至少包含一个
+getter语句，可以选择是否包含setter语句。
        
+
        更多参阅附属脚本声明。
        
+
        
+
        GRAMMAR OF A PROTOCOL SUBSCRIPT DECLARATION
        
+
        protocol-subscript-declaration → subscript-head­subscript-result­getter-setter-keyword-block­
        
+
        
+
        协议相关类型声明
        
+
        协议声明相关类型使用关键字typealias。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数
+语句中的类型参数很相似，但是它们在声明的协议中包含self关键字。在这些语句中，self指代和协议一致的可能的类型。
+获得更多信息和例子，查看相关类型或类型别名声明。
        
+
        
+
        GRAMMAR OF A PROTOCOL ASSOCIATED TYPE DECLARATION
        
+
        protocol-associated-type-declaration → typealias-head­type-inheritance-clause­opt­typealias-assignment­opt­
        
+
        
+
        
+
        构造器声明
        
+
        构造器声明会为程序内的类，结构体或枚举引入构造器。构造器使用关键字Init来声明，遵循两条基本形式。
        
+
        结构体，枚举，类可以有任意数量的构造器，但是类的构造器的规则和行为是不一样的。不像结构体和枚举那样，类
+有两种结构体，designed initializers 和convenience initializers，参见构造器一节。
        
+
        如下的形式声明了结构体，枚举和类的指定构造器：
        
+
        init(parameters) {
+     statements
+}
+
        类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个
+指定构造器。如果该类从它的超类处继承了任何属性，这些属性在当前类内被赋值或修饰时，必须带哦用一个超类的
+指定构造器。
        
+
        指定构造器可以在类声明的上下文中声明，因此它不能用扩展声明的方法加入一个类中。
        
+
        结构体和枚举的构造器可以带哦用其他的已声明的构造器，来委托其中一个火全部进行初始化过程。
        
+
        以关键字convenience来声明一个类的便利构造器：
        
+
        convenience init(parameters) {
+   statements
+}
+
        便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
+以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。
        
+
        你可以使用requierd关键字，将便利构造器和指定构造器标记为每个子类的构造器都必须拥有的。因为指定构造器
+不被子类继承，他们必须被立即执行。当子类直接执行所有超类的指定构造器(或使用便利构造器重写指定构造器)时，
+必需的便利构造器可以被隐式的执行，亦可以被继承。不像方法，附属脚本那样，你不需要为这些重写的构造器标注
+overrride关键字。
        
+
        查看更多关于不同声明方法的构造器的例子，参阅构造过程一节。
        
+
        
+
        GRAMMAR OF AN INITIALIZER DECLARATION
        
+
        initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­initializer-body­
+initializer-head → attributes­opt­convenience­opt­init­
+initializer-body → code-block­
        
+
        
+
        
+
        析构声明
        
+
        析构声明为类声明了一个析构器。析构器没有参数，遵循如下的格式：
        
+
        deinit {
+   statements
+}
+
        当类没有任何语句时将要被释放时，析构器会自动的被调用。析构器在类的声明体内只能被声明一次——但是不能在
+类的扩展声明内，每个类最多只能有一个。
        
+
        子类继承了它的超类的析构器，在子类将要被释放时隐式的调用。子类在所有析构器被执行完毕前不会被释放。
        
+
        析构器不会被直接调用。
        
+
        查看例子和如何在类的声明中使用析构器，参见析构过程一节
+。
        
+
        
+
        GRAMMAR OF A DEINITIALIZER DECLARATION
        
+
        deinitializer-declaration → attributes­opt­deinit­code-block
        
+
        
+
        
+
        扩展声明
        
+
        扩展声明用于扩展一个现存的类，结构体，枚举的行为。扩展声明以关键字extension开始，遵循如下的规则：
        
+
        extension type: adopted protocols {
+   declarations
+}
+
        一个扩展声明体包括零个或多个声明。这些声明可以包括计算型属性，计算型静态属性，实例方法，静态和类方法，构造器，
+附属脚本声明，甚至其他结构体，类，和枚举声明。扩展声明不能包含析构器，协议声明，存储型属性，属性监测器或其他
+的扩展属性。详细讨论和查看包含多种扩展声明的实例，参见扩展一节。
        
+
        扩展声明可以向现存的类，结构体，枚举内添加一致的协议。扩展声明不能向一个类中添加继承的类，因此
+type-inheritance-clause是一个只包含协议列表的扩展声明。
        
+
        属性，方法，现存类型的构造器不能被它们类型的扩展所重写。
        
+
        扩展声明可以包含构造器声明，这意味着，如果你扩展的类型在其他模块中定义，构造器声明必须委托另一个在
+那个模块里声明的构造器来恰当的初始化。
        
+
        
+
        GRAMMAR OF AN EXTENSION DECLARATION
        
+
        extension-declaration → extension­type-identifier­type-inheritance-clause­opt­extension-body­
+extension-body → {­declarations­opt­}­
        
+
        
+
        
+
        附属脚本声明(translated by 林)
        
+
        附属脚本用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字subscript，声明形式如下：
        
+
        
+
        subscript (parameter) -> (return type){
+    get{
+      statements
+    }
+    set(setter name){
+      statements
+    }
+}
+附属脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。
        
+
        
+
        变量(parameters)指定一个或多个用于在相关类型的附属脚本中访问元素的索引（例如，表达式object[i]中的i）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。返回类型(return type)指定被访问的元素的类型。
        
+
        和计算性属性一样，附属脚本声明支持对访问元素的读写操作。getter用于读取值，setter用于写入值。setter子句是可选的，当仅需要一个getter子句时，可以将二者都忽略且直接返回请求的值即可。也就是说，如果使用了setter子句，就必须使用getter子句。
        
+
        setter的名字和封闭的括号是可选的。如果使用了setter名称，它会被当做传给setter的变量的名称。如果不使用setter名称，那么传给setter的变量的名称默认是value。setter名称的类型必须与返回类型(return type)的类型相同。
        
+
        可以在附属脚本声明的类型中，可以重载附属脚本，只要变量(parameters)或返回类型(return type)与先前的不同即可。此时，必须使用override关键字声明那个被覆盖的附属脚本。(注：好乱啊！到底是重载还是覆盖？！)
        
+
        同样可以在协议声明的上下文中声明附属脚本，Protocol Subscript Declaration中有所描述。
        
+
        更多关于附属脚本和附属脚本声明的例子，请参考Subscripts。
        
+
        
+
        GRAMMAR OF A SUBSCRIPT DECLARATION
        
+
        subscript-declaration → subscript-head­subscript-result­code-block­
+subscript-declaration → subscript-head­subscript-result­getter-setter-block­
+subscript-declaration → subscript-head­subscript-result­getter-setter-keyword-block­
+subscript-head → attributes­opt­subscript­parameter-clause­
+subscript-result → ->­attributes­opt­type­
        
+
        
+
        
+
        运算符声明(translated by 林)
        
+
        运算符声明会向程序中引入中缀、前缀或后缀运算符，它使用上下文关键字operator声明。
+可以声明三种不同的缀性：中缀、前缀和后缀。操作符的缀性描述了操作符与它的操作数的相对位置。
+运算符声明有三种基本形式，每种缀性各一种。运算符的缀性通过在operator和运算符之间添加上下文关键字infix，prefix或postfix来指定。每种形式中，运算符的名字只能包含Operators中定义的运算符字符。
        
+
        下面的这种形式声明了一个新的中缀运算符：
        
+
        
+
        operator infix operator name{
+    precedence precedence level
+    associativity associativity
+ }
        
+
        
+
        中缀运算符是二元运算符，它可以被置于两个操作数之间，比如表达式1 + 2 中的加法运算符(+)。
        
+
        中缀运算符可以可选地指定优先级，结合性，或两者同时指定。
        
+
        运算符的优先级可以指定在没有括号包围的情况下，运算符与它的操作数如何紧密绑定的。可以使用上下文关键字precedence并优先级(precedence level)一起来指定一个运算符的优先级。优先级可以是0到255之间的任何一个数字(十进制整数)；与十进制整数字面量不同的是，它不可以包含任何下划线字符。尽管优先级是一个特定的数字，但它仅用作与另一个运算符比较(大小)。也就是说，一个操作数可以同时被两个运算符使用时，例如2 + 3 * 5，优先级更高的运算符将优先与操作数绑定。
        
+
        运算符的结合性可以指定在没有括号包围的情况下，优先级相同的运算符以何种顺序被分组的。可以使用上下文关键字associativity并结合性(associativity)一起来指定一个运算符的结合性，其中结合性可以说是上下文关键字left，right或none中的任何一个。左结合运算符以从左到右的形式分组。例如，减法运算符(-)具有左结合性，因此4 - 5 - 6被以(4 - 5) - 6的形式分组，其结果为-7。
+右结合运算符以从右到左的形式分组，对于设置为none的非结合运算符，它们不以任何形式分组。具有相同优先级的非结合运算符，不可以互相邻接。例如，表达式1 < 2 < 3非法的。
        
+
        声明时不指定任何优先级或结合性的中缀运算符，它们的优先级会被初始化为100，结合性被初始化为none。
        
+
        下面的这种形式声明了一个新的前缀运算符：
        
+
        
+
        operator prefix operator name{}
        
+
        
+
        紧跟在操作数前边的前缀运算符(prefix operator)是一元运算符，例如表达式++i中的前缀递增运算符(++)。
        
+
        前缀运算符的声明中不指定优先级。前缀运算符是非结合的。
        
+
        下面的这种形式声明了一个新的后缀运算符：
        
+
        
+
        operator postfix operator name{}
        
+
        
+
        紧跟在操作数后边的后缀运算符(postfix operator)是一元运算符，例如表达式i++中的前缀递增运算符(++)。
        
+
        和前缀运算符一样，后缀运算符的声明中不指定优先级。后缀运算符是非结合的。
        
+
        声明了一个新的运算符以后，需要声明一个跟这个运算符同名的函数来实现这个运算符。如何实现一个新的运算符，请参考Custom Operators。
        
+
        
+
        GRAMMAR OF AN OPERATOR DECLARATION
        
+
        operator-declaration → prefix-operator-declaration­  postfix-operator-declaration­  >infix-operator-declaration­
+prefix-operator-declaration → operator ­prefix­ operator­{­}­
+postfix-operator-declaration → operator ­postfix­ operator­{­}­
+infix-operator-declaration → operator­infix­operator­{­infix-operator-attributes­opt­}­
+infix-operator-attributes → precedence-clause­opt­associativity-clause­opt­
+precedence-clause → precedence­precedence-level­
+precedence-level → Digit 0 through 255
+associativity-clause → associativity­associativity­
+associativity → left­  right­  none
        
+
        
+
+                    
+                    
        
+                
                 
        
             
        • 
         
        
@@ -628,6 +1289,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/06_Attributes.html b/chapter3/06_Attributes.html
index 474c53fe..be390a79 100644
--- a/chapter3/06_Attributes.html
+++ b/chapter3/06_Attributes.html
@@ -5,12 +5,12 @@
         
         
         
-        特性 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,15 +587,25 @@
 
                 
        
                 
-                    
        
+                    
        
                     
-                        
        特性
        
+                        
        
+
        翻译：Hawstein
        
+
        校对：numbbbbb
        
+
        
+
        特性
        
 
        
+
        本页内容包括：
        
+
 
        特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。例如，required特性，当应用于一个类的指定或便利初始化器声明时，表明它的每个子类都必须实现那个初始化器。再比如noreturn特性，当应用于函数或方法类型时，表明该函数或方法不会返回到它的调用者。
        
 
        通过以下方式指定一个特性：符号@后面跟特性名，如果包含参数，则把参数带上：
        
 
        @attribute name
 @attribute name(attribute arguments)
 
        有些声明特性通过接收参数来指定特性的更多信息以及它是如何修饰一个特定的声明的。这些特性的参数写在小括号内，它们的格式由它们所属的特性来定义。
        
+
        
 
        声明特性
        
 
        声明特性只能应用于声明。然而，你也可以将noreturn特性应用于函数或方法类型。
        
 
        assignment
        
@@ -638,6 +648,7 @@ class ExampleClass {
 
        Interface Builder使用的声明特性
        
 
        Interface Builder特性是Interface Builder用来与Xcode同步的声明特性。Swift提供了以下的Interface Builder特性：IBAction，IBDesignable，IBInspectable，以及IBOutlet。这些特性与Objective-C中对应的特性在概念上是相同的。
        
 
        IBOutlet和IBInspectable用于修饰一个类的属性声明；IBAction特性用于修饰一个类的方法声明；IBDesignable用于修饰类的声明。
        
+
        
 
        类型特性
        
 
        类型特性只能用于修饰类型。然而，你也可以用noreturn特性去修饰函数或方法声明。
        
 
        auto_closure
        
@@ -702,6 +713,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/07_Patterns.html b/chapter3/07_Patterns.html
index 1ecc9c83..e393f0bd 100644
--- a/chapter3/07_Patterns.html
+++ b/chapter3/07_Patterns.html
@@ -5,12 +5,12 @@
         
         
         
-        模式 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,10 +587,24 @@
 
                 
        
                 
-                    
        
+                    
        
                     
-                        
        模式（Patterns）
        
+                        
        
+
        翻译：honghaoz
        
+
        校对：numbbbbb
        
+
        
+
        模式（Patterns）
        
 
        
+
        本页内容包括：
        
+
 
        模式（pattern）代表了单个值或者复合值的结构。例如，元组(1, 2)的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，(x, y)可以匹配元组(1, 2)，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
        
 
        在Swift中，模式出现在变量和常量的声明（在它们的左侧），for-in语句和switch语句（在他们的case标签）中。尽管任何模式都可以出现在switch语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
        
 
        你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。
        
@@ -604,6 +618,7 @@
 
        pattern → type-casting-pattern
        
 
        pattern → expression-pattern
        
 
        • 
+
        
 
        通配符模式（Wildcard Pattern）
        
 
        通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了1...3的循环，并忽略了每次循环的值：
        
 
                for _ in 1...3 {
@@ -613,6 +628,7 @@
 
        通配符模式的语法：
        
 
        wildcard-pattern → _
        
 
+
        
 
        标识符模式（Identifier Pattern）
        
 
        标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，someValue是一个标识符模式，匹配了类型是Int的42。
        
 
                let someValue = 42
@@ -622,6 +638,7 @@
 
        标识符模式的语法：
        
 
        identifier-pattern → identifier
        
 
+
        
 
        值绑定模式（Value-Binding Pattern）
        
 
        值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字let,绑定给变量时，用关键之var。
        
 
        标识符模式包含在值绑定模式中，绑定新的变量或常量到匹配的值。例如，你可以分解一个元组的元素，并把每个元素绑定到相应的标识符模式中。
        
@@ -637,6 +654,7 @@
 
        值绑定模式的语法：
        
 
        value-binding-pattern → var pattern | let pattern
        
 
+
        
 
        元组模式（Tuple Pattern）
        
 
        元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。
        
 
        你可以使用类型注释来限制一个元组模式来匹配某种元组类型。例如，在常量申明let (x, y): (Int, Int) = (1, 2)中的元组模式(x, y): (Int, Int)，只匹配两个元素都是Int这种类型的元组。如果仅需要限制一个元组模式中的某几个元素，只需要直接对这几个元素提供类型注释即可。例如，在let (x: String, y)中的元组模式，只要某个元组类型是包含两个元素，且第一个元素类型是String，则被匹配。
        
@@ -656,6 +674,7 @@
 
        tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element, tuple-pattern-element-list
        
 
        tuple-pattern-element → pattern
        
 
+
        
 
        枚举案例模式（Enumeration Case Pattern）
        
 
        枚举案例模式匹配现有的枚举类型的某种案例。枚举案例模式仅在switch语句中的case标签中出现。
        
 
        如果你准备匹配的枚举案例有任何关联的值，则相应的枚举案例模式必须指定一个包含每个关联值元素的元组模式。关于使用switch语句来匹配包含关联值枚举案例的例子，请参阅Associated Values.
        
@@ -663,6 +682,7 @@
 
        枚举案例模式的语法：
        
 
        enum-case-pattern → type-identifier opt . enum-case-name tuple-pattern opt
        
 
+
        
 
        类型转换模式（Type-Casting Patterns）
        
 
        有两种类型转换模式，is模式和as模式。这两种模式均只出现在switch语句中的case标签中。is模式和as模式有以下形式：
        
 
                is type
@@ -676,6 +696,7 @@
 
        is-pattern → istype
        
 
        as-pattern → patternastype
        
 
+
        
 
        表达式模式（Expression Pattern）
        
 
        表达式模式代表了一个表达式的值。这个模式只出现在switch语句中的case标签中。
        
 
        由表达式模式所代表的表达式用Swift标准库中的~=操作符与输入表达式的值进行比较。如果~=操作符返回true，则匹配成功。默认情况下，~=操作符使用==操作符来比较两个相同类型的值。它也可以匹配一个整数值与一个Range对象中的整数范围，正如下面这个例子所示：
        
@@ -752,6 +773,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/08_Generic_Parameters_and_Arguments.html b/chapter3/08_Generic_Parameters_and_Arguments.html
index f4381ab2..6e08505d 100644
--- a/chapter3/08_Generic_Parameters_and_Arguments.html
+++ b/chapter3/08_Generic_Parameters_and_Arguments.html
@@ -5,12 +5,12 @@
         
         
         
-        泛型参数 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
        
+    
        
     
        
     
     
@@ -98,7 +98,7 @@
     
     
        
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
        
 
        
 
@@ -119,7 +119,7 @@
         
 
         
      • 
-             Introduction
+             序
         
        • 
         
     
@@ -331,7 +331,7 @@
         
      • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,9 +587,13 @@
 
                 
        
                 
-                    
        
+                    
        
                     
-                        
        泛型参数
        
+                        
        
+
        翻译：fd5788
        
+
        校对：yankuangshi
        
+
        
+
        泛型参数
        
 
        
 
        本页包含内容：
        
 
          
@@ -703,6 +707,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/09_Summary_of_the_Grammar.html b/chapter3/09_Summary_of_the_Grammar.html
index 04b06d50..1af9c81c 100644
--- a/chapter3/09_Summary_of_the_Grammar.html
+++ b/chapter3/09_Summary_of_the_Grammar.html
@@ -5,12 +5,12 @@
         
         
         
-        语法总结 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -19,8 +19,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -44,7 +44,7 @@
 
 
         
-    
          
+    
          
     
          
     
     
@@ -96,7 +96,7 @@
     
     
          
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
          
 
          
 
@@ -117,7 +117,7 @@
         
 
         
        • 
-             Introduction
+             序
         
          • 
         
     
@@ -329,7 +329,7 @@
         
        • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -532,7 +532,7 @@
     
         
     
-        
+        
     
         
     
@@ -585,460 +585,831 @@
 
                 
          
                 
-                    
          
+                    
          
                     
-                        
          语法总结
          
+                        
          
+
          翻译：StanZhai
          
+
          校对：xielingwang
          
+
          
+
          语法总结
          
 
          
 
          本页包含内容：
          
 
-
          
+
          
 
          语句
          
 
          
-
          语句语法
          statement → expression ; opt
          statement → declaration ; opt
          statement → loop-statement ; opt
          statement → branch-statement ; opt
          statement → labeled-statement
          statement → control-transfer-statement ; opt
          statements → statement statements opt  
          
+
          语句语法
+statement → expression ; opt
+statement → declaration ; opt
+statement → loop-statement ; opt
+statement → branch-statement ; opt
+statement → labeled-statement
+statement → control-transfer-statement ; opt
+statements → statement statements opt
          
 
          
 
          
 
 
          
-
          循环语句语法
          loop-statement → for-statement
          loop-statement → for-in-statement
          loop-statement → while-statement
          loop-statement → do-while-statement  
          
+
          循环语句语法
+loop-statement → for-statement
+loop-statement → for-in-statement
+loop-statement → while-statement
+loop-statement → do-while-statement
          
 
          
 
          
 
 
          
-
          For 循环语法
          for-statement → for for-init opt ; expression opt ; expression opt code-block
          for-statement → for ( for-init opt ; expression opt ; expression opt ) code-block
          for-init → variable-declaration | expression-list  
          
+
          For 循环语法
+for-statement → for for-init opt ; expression opt ; expression opt code-block
+for-statement → for ( for-init opt ; expression opt ; expression opt ) code-block
+for-init → variable-declaration | expression-list
          
 
          
 
          
 
 
          
-
          For-In 循环语法
          for-in-statement → for pattern in expression code-block  
          
+
          For-In 循环语法
+for-in-statement → for pattern in expression code-block
          
 
          
 
          
 
 
          
-
          While 循环语法
          while-statement → while while-condition code-block
          while-condition → expression | declaration  
          
+
          While 循环语法
+while-statement → while while-condition code-block
+while-condition → expression | declaration
          
 
          
 
          
 
 
          
-
          Do-While 循环语法
          do-while-statement → do code-block while while-condition  
          
+
          Do-While 循环语法
+do-while-statement → do code-block while while-condition
          
 
          
 
          
 
 
          
-
          分支语句语法
          branch-statement → if-statement
          branch-statement → switch-statement  
          
+
          分支语句语法
+branch-statement → if-statement
+branch-statement → switch-statement
          
 
          
 
          
 
 
          
-
          If 语句语法
          if-statement → if if-condition code-block else-clause opt
          if-condition → expression | declaration
          else-clause → else code-block | else if-statement  
          
+
          If 语句语法
+if-statement → if if-condition code-block else-clause opt
+if-condition → expression | declaration
+else-clause → else code-block | else if-statement
          
 
          
 
          
 
 
          
-
          Switch 语句语法
          switch-statement → switch expression { switch-cases opt }
          switch-cases → switch-case switch-cases opt
          switch-case → case-label statements | default-label statements
          switch-case → case-label ; | default-label ;
          case-label → case case-item-list :
          case-item-list → pattern guard-clause opt | pattern guard-clause opt , case-item-list
          default-label → default :
          guard-clause → where guard-expression
          guard-expression → expression  
          
+
          Switch 语句语法
+switch-statement → switch expression { switch-cases opt }
+switch-cases → switch-case switch-cases opt
+switch-case → case-label statements | default-label statements
+switch-case → case-label ; | default-label ;
+case-label → case case-item-list :
+case-item-list → pattern guard-clause opt | pattern guard-clause opt , case-item-list
+default-label → default :
+guard-clause → where guard-expression
+guard-expression → expression
          
 
          
 
          
 
 
          
-
          带标签的语句语法
          labeled-statement → statement-label loop-statement | statement-label switch-statement
          statement-label → label-name :
          label-name → identifier  
          
+
          带标签的语句语法
+labeled-statement → statement-label loop-statement | statement-label switch-statement
+statement-label → label-name :
+label-name → identifier
          
 
          
 
          
 
 
          
-
          控制传递语句语法
          control-transfer-statement → break-statement
          control-transfer-statement → continue-statement
          control-transfer-statement → fallthrough-statement
          control-transfer-statement → return-statement  
          
+
          控制传递语句语法
+control-transfer-statement → break-statement
+control-transfer-statement → continue-statement
+control-transfer-statement → fallthrough-statement
+control-transfer-statement → return-statement
          
 
          
 
          
 
 
          
-
          Break 语句语法
          break-statement → break label-name opt  
          
+
          Break 语句语法
+break-statement → break label-name opt
          
 
          
 
          
 
 
          
-
          Continue 语句语法
          continue-statement → continue label-name opt  
          
+
          Continue 语句语法
+continue-statement → continue label-name opt
          
 
          
 
          
 
 
          
-
          Fallthrough 语句语法
          fallthrough-statement → fallthrough  
          
+
          Fallthrough 语句语法
+fallthrough-statement → fallthrough
          
 
          
 
          
 
 
          
-
          Return 语句语法
          return-statement → return expression opt  
          
+
          Return 语句语法
+return-statement → return expression opt
          
 
          
-
          
+
          
 
          泛型参数
          
 
          
-
          泛型形参子句语法
          generic-parameter-clause → < generic-parameter-list requirement-clause opt >
          generic-parameter-list → generic-parameter | generic-parameter , generic-parameter-list
          generic-parameter → type-name
          generic-parameter → type-name : type-identifier
          generic-parameter → type-name : protocol-composition-type
          requirement-clause → where requirement-list
          requirement-list → requirement | requirement , requirement-list
          requirement → conformance-requirement | same-type-requirement
          conformance-requirement → type-identifier : type-identifier
          conformance-requirement → type-identifier : protocol-composition-type
          same-type-requirement → type-identifier == type-identifier  
          
+
          泛型形参子句语法
+generic-parameter-clause → < generic-parameter-list requirement-clause opt >
+generic-parameter-list → generic-parameter | generic-parameter , generic-parameter-list
+generic-parameter → type-name
+generic-parameter → type-name : type-identifier
+generic-parameter → type-name : protocol-composition-type
+requirement-clause → where requirement-list
+requirement-list → requirement | requirement , requirement-list
+requirement → conformance-requirement | same-type-requirement
+conformance-requirement → type-identifier : type-identifier
+conformance-requirement → type-identifier : protocol-composition-type
+same-type-requirement → type-identifier == type-identifier
          
 
          
 
          
 
 
          
-
          泛型实参子句语法
          generic-argument-clause → < generic-argument-list >
          generic-argument-list → generic-argument | generic-argument , generic-argument-list
          generic-argument → type  
          
+
          泛型实参子句语法
+generic-argument-clause → < generic-argument-list >
+generic-argument-list → generic-argument | generic-argument , generic-argument-list
+generic-argument → type
          
 
          
-
          
+
          
 
          声明 (Declarations)
          
 
          
-
          声明语法
          declaration → import-declaration
          declaration → constant-declaration
          declaration → variable-declaration
          declaration → typealias-declaration
          declaration → function-declaration
          declaration → enum-declaration
          declaration → struct-declaration
          declaration → class-declaration
          declaration → protocol-declaration
          declaration → initializer-declaration
          declaration → deinitializer-declaration
          declaration → extension-declaration
          declaration → subscript-declaration
          declaration → operator-declaration
          declarations → declaration declarations opt
          declaration-specifiers → declaration-specifier declaration-specifiers opt
          declaration-specifier → class | mutating | nonmutating | override | static | unowned | unowned(safe) | unowned(unsafe) | weak  
          
+
          声明语法
+declaration → import-declaration
+declaration → constant-declaration
+declaration → variable-declaration
+declaration → typealias-declaration
+declaration → function-declaration
+declaration → enum-declaration
+declaration → struct-declaration
+declaration → class-declaration
+declaration → protocol-declaration
+declaration → initializer-declaration
+declaration → deinitializer-declaration
+declaration → extension-declaration
+declaration → subscript-declaration
+declaration → operator-declaration
+declarations → declaration declarations opt
+declaration-specifiers → declaration-specifier declaration-specifiers opt
+declaration-specifier → class | mutating | nonmutating | override | static | unowned | unowned(safe) | unowned(unsafe) | weak
          
 
          
 
          
 
 
          
-
          顶级声明语法
          top-level-declaration → statements opt  
          
+
          顶级声明语法
+top-level-declaration → statements opt
          
 
          
 
          
 
 
          
-
          代码块语法
          code-block → { statements opt }  
          
+
          代码块语法
+code-block → { statements opt }
          
 
          
 
          
 
 
          
-
          Import 声明语法
          import-declaration → attributes opt import import-kind opt import-path
          import-kind → typealias | struct | class | enum | protocol | var | func
          import-path → import-path-identifier | import-path-identifier . import-path
          import-path-identifier → identifier | operator  
          
+
          Import 声明语法
+import-declaration → attributes opt import import-kind opt import-path
+import-kind → typealias | struct | class | enum | protocol | var | func
+import-path → import-path-identifier | import-path-identifier . import-path
+import-path-identifier → identifier | operator
          
 
          
 
          
 
 
          
-
          常数声明语法
          constant-declaration → attributes opt declaration-specifiers opt let pattern-initializer-list
          pattern-initializer-list → pattern-initializer | pattern-initializer , pattern-initializer-list
          pattern-initializer → pattern initializer opt
          initializer → = expression  
          
+
          常数声明语法
+constant-declaration → attributes opt declaration-specifiers opt let pattern-initializer-list
+pattern-initializer-list → pattern-initializer | pattern-initializer , pattern-initializer-list
+pattern-initializer → pattern initializer opt
+initializer → = expression
          
 
          
 
          
 
 
          
-
          变量声明语法
          variable-declaration → variable-declaration-head pattern-initializer-list
          variable-declaration → variable-declaration-head variable-name type-annotation code-block
          variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-block
          variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block
          variable-declaration → variable-declaration-head variable-name type-annotation initializer opt willSet-didSet-block
          variable-declaration-head → attributes opt declaration-specifiers opt var
          variable-name → identifier
          getter-setter-block → { getter-clause setter-clause opt }
          getter-setter-block → { setter-clause getter-clause }
          getter-clause → attributes opt get code-block
          setter-clause → attributes opt set setter-name opt code-block
          setter-name → ( identifier )
          getter-setter-keyword-block → { getter-keyword-clause setter-keyword-clause opt }
          getter-setter-keyword-block → { setter-keyword-clause getter-keyword-clause }
          getter-keyword-clause → attributes opt get
          setter-keyword-clause → attributes opt set
          willSet-didSet-block → { willSet-clause didSet-clause opt }
          willSet-didSet-block → { didSet-clause willSet-clause }
          willSet-clause → attributes opt willSet setter-name opt code-block
          didSet-clause → attributes opt didSet setter-name opt code-block  
          
+
          变量声明语法
+variable-declaration → variable-declaration-head pattern-initializer-list
+variable-declaration → variable-declaration-head variable-name type-annotation code-block
+variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-block
+variable-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block
+variable-declaration → variable-declaration-head variable-name type-annotation initializer opt willSet-didSet-block
+variable-declaration-head → attributes opt declaration-specifiers opt var
+variable-name → identifier
+getter-setter-block → { getter-clause setter-clause opt }
+getter-setter-block → { setter-clause getter-clause }
+getter-clause → attributes opt get code-block
+setter-clause → attributes opt set setter-name opt code-block
+setter-name → ( identifier )
+getter-setter-keyword-block → { getter-keyword-clause setter-keyword-clause opt }
+getter-setter-keyword-block → { setter-keyword-clause getter-keyword-clause }
+getter-keyword-clause → attributes opt get
+setter-keyword-clause → attributes opt set
+willSet-didSet-block → { willSet-clause didSet-clause opt }
+willSet-didSet-block → { didSet-clause willSet-clause }
+willSet-clause → attributes opt willSet setter-name opt code-block
+didSet-clause → attributes opt didSet setter-name opt code-block
          
 
          
 
          
 
 
          
-
          类型别名声明语法
          typealias-declaration → typealias-head typealias-assignment
          typealias-head → typealias typealias-name
          typealias-name → identifier
          typealias-assignment → = type  
          
+
          类型别名声明语法
+typealias-declaration → typealias-head typealias-assignment
+typealias-head → typealias typealias-name
+typealias-name → identifier
+typealias-assignment → = type
          
 
          
 
          
 
 
          
-
          函数声明语法
          function-declaration → function-head function-name generic-parameter-clause opt function-signature function-body
          function-head → attributes opt declaration-specifiers opt func
          function-name → identifier | operator
          function-signature → parameter-clauses function-result opt
          function-result → -> attributes opt type
          function-body → code-block
          parameter-clauses → parameter-clause parameter-clauses opt
          parameter-clause → ( ) | ( parameter-list ... opt )
          parameter-list → parameter | parameter , parameter-list
          parameter → inout opt let opt # opt parameter-name local-parameter-name opt type-annotation default-argument-clause opt
          parameter → inout opt var # opt parameter-name local-parameter-name opt type-annotation default-argument-clause opt
          parameter → attributes opt type
          parameter-name → identifier | _
          local-parameter-name → identifier | _
          default-argument-clause → = expression  
          
+
          函数声明语法
+function-declaration → function-head function-name generic-parameter-clause opt function-signature function-body
+function-head → attributes opt declaration-specifiers opt func
+function-name → identifier | operator
+function-signature → parameter-clauses function-result opt
+function-result → -> attributes opt type
+function-body → code-block
+parameter-clauses → parameter-clause parameter-clauses opt
+parameter-clause → ( ) | ( parameter-list ... opt )
+parameter-list → parameter | parameter , parameter-list
+parameter → inout opt let opt # opt parameter-name local-parameter-name opt type-annotation default-argument-clause opt
+parameter → inout opt var # opt parameter-name local-parameter-name opt type-annotation default-argument-clause opt
+parameter → attributes opt type
+parameter-name → identifier | _
+local-parameter-name → identifier | _
+default-argument-clause → = expression
          
 
          
 
          
 
 
          
-
          枚举声明语法
          enum-declaration → attributes opt union-style-enum | attributes opt raw-value-style-enum
          union-style-enum → enum-name generic-parameter-clause opt { union-style-enum-members opt }
          union-style-enum-members → union-style-enum-member union-style-enum-members opt
          union-style-enum-member → declaration | union-style-enum-case-clause
          union-style-enum-case-clause → attributes opt case union-style-enum-case-list
          union-style-enum-case-list → union-style-enum-case | union-style-enum-case , union-style-enum-case-list
          union-style-enum-case → enum-case-name tuple-type opt
          enum-name → identifier
          enum-case-name → identifier
          raw-value-style-enum → enum-name generic-parameter-clause opt : type-identifier { raw-value-style-enum-members opt }
          raw-value-style-enum-members → raw-value-style-enum-member raw-value-style-enum-members opt
          raw-value-style-enum-member → declaration | raw-value-style-enum-case-clause
          raw-value-style-enum-case-clause → attributes opt case raw-value-style-enum-case-list
          raw-value-style-enum-case-list → raw-value-style-enum-case | raw-value-style-enum-case , raw-value-style-enum-case-list
          raw-value-style-enum-case → enum-case-name raw-value-assignment opt
          raw-value-assignment → = literal  
          
+
          枚举声明语法
+enum-declaration → attributes opt union-style-enum | attributes opt raw-value-style-enum
+union-style-enum → enum-name generic-parameter-clause opt { union-style-enum-members opt }
+union-style-enum-members → union-style-enum-member union-style-enum-members opt
+union-style-enum-member → declaration | union-style-enum-case-clause
+union-style-enum-case-clause → attributes opt case union-style-enum-case-list
+union-style-enum-case-list → union-style-enum-case | union-style-enum-case , union-style-enum-case-list
+union-style-enum-case → enum-case-name tuple-type opt
+enum-name → identifier
+enum-case-name → identifier
+raw-value-style-enum → enum-name generic-parameter-clause opt : type-identifier { raw-value-style-enum-members opt }
+raw-value-style-enum-members → raw-value-style-enum-member raw-value-style-enum-members opt
+raw-value-style-enum-member → declaration | raw-value-style-enum-case-clause
+raw-value-style-enum-case-clause → attributes opt case raw-value-style-enum-case-list
+raw-value-style-enum-case-list → raw-value-style-enum-case | raw-value-style-enum-case , raw-value-style-enum-case-list
+raw-value-style-enum-case → enum-case-name raw-value-assignment opt
+raw-value-assignment → = literal
          
 
          
 
          
 
 
          
-
          结构体声明语法
          struct-declaration → attributes opt struct struct-name generic-parameter-clause opt type-inheritance-clause opt struct-body
          struct-name → identifier
          struct-body → { declarations opt }  
          
+
          结构体声明语法
+struct-declaration → attributes opt struct struct-name generic-parameter-clause opt type-inheritance-clause opt struct-body
+struct-name → identifier
+struct-body → { declarations opt }
          
 
          
 
          
 
 
          
-
          类声明语法
          class-declaration → attributes opt class class-name generic-parameter-clause opt type-inheritance-clause opt class-body
          class-name → identifier
          class-body → { declarations opt }  
          
+
          类声明语法
+class-declaration → attributes opt class class-name generic-parameter-clause opt type-inheritance-clause opt class-body
+class-name → identifier
+class-body → { declarations opt }
          
 
          
 
          
 
 
          
-
          协议声明语法
          protocol-declaration → attributes opt protocol protocol-name type-inheritance-clause opt protocol-body
          protocol-name → identifier
          protocol-body → { protocol-member-declarations opt }
          protocol-member-declaration → protocol-property-declaration
          protocol-member-declaration → protocol-method-declaration
          protocol-member-declaration → protocol-initializer-declaration
          protocol-member-declaration → protocol-subscript-declaration
          protocol-member-declaration → protocol-associated-type-declaration
          protocol-member-declarations → protocol-member-declaration protocol-member-declarations opt  
          
+
          协议声明语法
+protocol-declaration → attributes opt protocol protocol-name type-inheritance-clause opt protocol-body
+protocol-name → identifier
+protocol-body → { protocol-member-declarations opt }
+protocol-member-declaration → protocol-property-declaration
+protocol-member-declaration → protocol-method-declaration
+protocol-member-declaration → protocol-initializer-declaration
+protocol-member-declaration → protocol-subscript-declaration
+protocol-member-declaration → protocol-associated-type-declaration
+protocol-member-declarations → protocol-member-declaration protocol-member-declarations opt
          
 
          
 
          
 
 
          
-
          协议属性声明语法
          protocol-property-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block  
          
+
          协议属性声明语法
+protocol-property-declaration → variable-declaration-head variable-name type-annotation getter-setter-keyword-block
          
 
          
 
          
 
 
          
-
          协议方法声明语法
          protocol-method-declaration → function-head function-name generic-parameter-clause opt function-signature  
          
+
          协议方法声明语法
+protocol-method-declaration → function-head function-name generic-parameter-clause opt function-signature
          
 
          
 
          
 
 
          
-
          协议构造函数声明语法
          protocol-initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause  
          
+
          协议构造函数声明语法
+protocol-initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause
          
 
          
 
          
 
 
          
-
          协议附属脚本声明语法
          protocol-subscript-declaration → subscript-head subscript-result getter-setter-keyword-block  
          
+
          协议附属脚本声明语法
+protocol-subscript-declaration → subscript-head subscript-result getter-setter-keyword-block
          
 
          
 
          
 
 
          
-
          协议关联类型声明语法
          protocol-associated-type-declaration → typealias-head type-inheritance-clause opt typealias-assignment opt  
          
+
          协议关联类型声明语法
+protocol-associated-type-declaration → typealias-head type-inheritance-clause opt typealias-assignment opt
          
 
          
 
          
 
 
          
-
          构造函数声明语法
          initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause initializer-body
          initializer-head → attributes opt convenience opt init
          initializer-body → code-block  
          
+
          构造函数声明语法
+initializer-declaration → initializer-head generic-parameter-clause opt parameter-clause initializer-body
+initializer-head → attributes opt convenience opt init
+initializer-body → code-block
          
 
          
 
          
 
 
          
-
          析构函数声明语法
          deinitializer-declaration → attributes opt deinit code-block  
          
+
          析构函数声明语法
+deinitializer-declaration → attributes opt deinit code-block
          
 
          
 
          
 
 
          
-
          扩展声明语法
          extension-declaration → extension type-identifier type-inheritance-clause opt extension-body
          extension-body → { declarations opt }  
          
+
          扩展声明语法
+extension-declaration → extension type-identifier type-inheritance-clause opt extension-body
+extension-body → { declarations opt }
          
 
          
 
          
 
 
          
-
          附属脚本声明语法
          subscript-declaration → subscript-head subscript-result code-block
          subscript-declaration → subscript-head subscript-result getter-setter-block
          subscript-declaration → subscript-head subscript-result getter-setter-keyword-block
          subscript-head → attributes opt subscript parameter-clause
          subscript-result → -> attributes opt type  
          
+
          附属脚本声明语法
+subscript-declaration → subscript-head subscript-result code-block
+subscript-declaration → subscript-head subscript-result getter-setter-block
+subscript-declaration → subscript-head subscript-result getter-setter-keyword-block
+subscript-head → attributes opt subscript parameter-clause
+subscript-result → -> attributes opt type
          
 
          
 
          
 
 
          
-
          运算符声明语法
          operator-declaration → prefix-operator-declaration | postfix-operator-declaration | infix-operator-declaration
          prefix-operator-declaration → operator prefix operator { }
          postfix-operator-declaration → operator postfix operator { }
          infix-operator-declaration → operator infix operator { infix-operator-attributes opt }
          infix-operator-attributes → precedence-clause opt associativity-clause opt
          precedence-clause → precedence precedence-level
          precedence-level → Digit 0 through 255
          associativity-clause → associativity associativity
          associativity → left | right | none  
          
+
          运算符声明语法
+operator-declaration → prefix-operator-declaration | postfix-operator-declaration | infix-operator-declaration
+prefix-operator-declaration → operator prefix operator { }
+postfix-operator-declaration → operator postfix operator { }
+infix-operator-declaration → operator infix operator { infix-operator-attributes opt }
+infix-operator-attributes → precedence-clause opt associativity-clause opt
+precedence-clause → precedence precedence-level
+precedence-level → Digit 0 through 255
+associativity-clause → associativity associativity
+associativity → left | right | none
          
 
          
-
          
+
          
 
          模式
          
 
          
-
          模式语法
          pattern → wildcard-pattern type-annotation opt
          pattern → identifier-pattern type-annotation opt
          pattern → value-binding-pattern
          pattern → tuple-pattern type-annotation opt
          pattern → enum-case-pattern
          pattern → type-casting-pattern
          pattern → expression-pattern  
          
+
          模式语法
+pattern → wildcard-pattern type-annotation opt
+pattern → identifier-pattern type-annotation opt
+pattern → value-binding-pattern
+pattern → tuple-pattern type-annotation opt
+pattern → enum-case-pattern
+pattern → type-casting-pattern
+pattern → expression-pattern
          
 
          
 
          
 
 
          
-
          通配符模式语法
          wildcard-pattern → _  
          
+
          通配符模式语法
+wildcard-pattern → _
          
 
          
 
          
 
 
          
-
          标识符模式语法
          identifier-pattern → identifier  
          
+
          标识符模式语法
+identifier-pattern → identifier
          
 
          
 
          
 
 
          
-
          值绑定模式语法
          value-binding-pattern → var pattern | let pattern  
          
+
          值绑定模式语法
+value-binding-pattern → var pattern | let pattern
          
 
          
 
          
 
 
          
-
          元组模式语法
          tuple-pattern → ( tuple-pattern-element-list opt )
          tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element , tuple-pattern-element-list
          tuple-pattern-element → pattern  
          
+
          元组模式语法
+tuple-pattern → ( tuple-pattern-element-list opt )
+tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element , tuple-pattern-element-list
+tuple-pattern-element → pattern
          
 
          
 
          
 
 
          
-
          枚举用例模式语法
          enum-case-pattern → type-identifier opt . enum-case-name tuple-pattern opt  
          
+
          枚举用例模式语法
+enum-case-pattern → type-identifier opt . enum-case-name tuple-pattern opt
          
 
          
 
          
 
 
          
-
          类型转换模式语法
          type-casting-pattern → is-pattern | as-pattern
          is-pattern → is type
          as-pattern → pattern as type  
          
+
          类型转换模式语法
+type-casting-pattern → is-pattern | as-pattern
+is-pattern → is type
+as-pattern → pattern as type
          
 
          
 
          
 
 
          
-
          表达式模式语法
          expression-pattern → expression  
          
+
          表达式模式语法
+expression-pattern → expression
          
 
          
-
          
+
          
 
          特性
          
 
          
-
          特性语法
          attribute → @ attribute-name attribute-argument-clause opt
          attribute-name → identifier
          attribute-argument-clause → ( balanced-tokens opt )
          attributes → attribute attributes opt
          balanced-tokens → balanced-token balanced-tokens opt
          balanced-token → ( balanced-tokens opt )
          balanced-token → [ balanced-tokens opt ]
          balanced-token → { balanced-tokens opt }
          balanced-token → Any identifier, keyword, literal, or operator
          balanced-token → Any punctuation except (­, )­, [­, ]­, {­, or }­  
          
+
          特性语法
+attribute → @ attribute-name attribute-argument-clause opt
+attribute-name → identifier
+attribute-argument-clause → ( balanced-tokens opt )
+attributes → attribute attributes opt
+balanced-tokens → balanced-token balanced-tokens opt
+balanced-token → ( balanced-tokens opt )
+balanced-token → [ balanced-tokens opt ]
+balanced-token → { balanced-tokens opt }
+balanced-token → Any identifier, keyword, literal, or operator
+balanced-token → Any punctuation except (­, )­, [­, ]­, {­, or }­
          
 
          
-
          
+
          
 
          表达式
          
 
          
-
          表达式语法
          expression → prefix-expression binary-expressions opt
          expression-list → expression | expression , expression-list  
          
+
          表达式语法
+expression → prefix-expression binary-expressions opt
+expression-list → expression | expression , expression-list
          
 
          
 
          
 
 
          
-
          前缀表达式语法
          prefix-expression → prefix-operator opt postfix-expression
          prefix-expression → in-out-expression
          in-out-expression → & identifier  
          
+
          前缀表达式语法
+prefix-expression → prefix-operator opt postfix-expression
+prefix-expression → in-out-expression
+in-out-expression → & identifier
          
 
          
 
          
 
 
          
-
          二进制表达式语法
          binary-expression → binary-operator prefix-expression
          binary-expression → assignment-operator prefix-expression
          binary-expression → conditional-operator prefix-expression
          binary-expression → type-casting-operator
          binary-expressions → binary-expression binary-expressions opt  
          
+
          二进制表达式语法
+binary-expression → binary-operator prefix-expression
+binary-expression → assignment-operator prefix-expression
+binary-expression → conditional-operator prefix-expression
+binary-expression → type-casting-operator
+binary-expressions → binary-expression binary-expressions opt
          
 
          
 
          
 
 
          
-
          赋值运算符语法
          assignment-operator → =  
          
+
          赋值运算符语法
+assignment-operator → =
          
 
          
 
          
 
 
          
-
          条件运算符语法
          conditional-operator → ? expression :  
          
+
          条件运算符语法
+conditional-operator → ? expression :
          
 
          
 
          
 
 
          
-
          类型转换运算符语法
          type-casting-operator → is type | as ? opt type  
          
+
          类型转换运算符语法
+type-casting-operator → is type | as ? opt type
          
 
          
 
          
 
 
          
-
          主表达式语法
          primary-expression → identifier generic-argument-clause opt
          primary-expression → literal-expression
          primary-expression → self-expression
          primary-expression → superclass-expression
          primary-expression → closure-expression
          primary-expression → parenthesized-expression
          primary-expression → implicit-member-expression
          primary-expression → wildcard-expression  
          
+
          主表达式语法
+primary-expression → identifier generic-argument-clause opt
+primary-expression → literal-expression
+primary-expression → self-expression
+primary-expression → superclass-expression
+primary-expression → closure-expression
+primary-expression → parenthesized-expression
+primary-expression → implicit-member-expression
+primary-expression → wildcard-expression
          
 
          
 
          
 
 
          
-
          字面量表达式语法
          literal-expression → literal
          literal-expression → array-literal | dictionary-literal
          literal-expression → __FILE__ | __LINE__ | __COLUMN__ | __FUNCTION__
          array-literal → [ array-literal-items opt ]
          array-literal-items → array-literal-item , opt | array-literal-item , array-literal-items
          array-literal-item → expression
          dictionary-literal → [ dictionary-literal-items ] | [ : ]
          dictionary-literal-items → dictionary-literal-item , opt | dictionary-literal-item , dictionary-literal-items
          dictionary-literal-item → expression : expression  
          
+
          字面量表达式语法
+literal-expression → literal
+literal-expression → array-literal | dictionary-literal
+literal-expression → __FILE__ | __LINE__ | __COLUMN__ | __FUNCTION__
+array-literal → [ array-literal-items opt ]
+array-literal-items → array-literal-item , opt | array-literal-item , array-literal-items
+array-literal-item → expression
+dictionary-literal → [ dictionary-literal-items ] | [ : ]
+dictionary-literal-items → dictionary-literal-item , opt | dictionary-literal-item , dictionary-literal-items
+dictionary-literal-item → expression : expression
          
 
          
 
          
 
 
          
-
          Self 表达式语法
          self-expression → self
          self-expression → self . identifier
          self-expression → self [ expression ]
          self-expression → self . init  
          
+
          Self 表达式语法
+self-expression → self
+self-expression → self . identifier
+self-expression → self [ expression ]
+self-expression → self . init
          
 
          
 
          
 
 
          
-
          超类表达式语法
          superclass-expression → superclass-method-expression | superclass-subscript-expression | superclass-initializer-expression
          superclass-method-expression → super . identifier
          superclass-subscript-expression → super [ expression ]
          superclass-initializer-expression → super . init  
          
+
          超类表达式语法
+superclass-expression → superclass-method-expression | superclass-subscript-expression | superclass-initializer-expression
+superclass-method-expression → super . identifier
+superclass-subscript-expression → super [ expression ]
+superclass-initializer-expression → super . init
          
 
          
 
          
 
 
          
-
          闭包表达式语法
          closure-expression → { closure-signature opt statements }
          closure-signature → parameter-clause function-result opt in
          closure-signature → identifier-list function-result opt in
          closure-signature → capture-list parameter-clause function-result opt in
          closure-signature → capture-list identifier-list function-result opt in
          closure-signature → capture-list in
          capture-list → [ capture-specifier expression ]
          capture-specifier → weak | unowned | unowned(safe) | unowned(unsafe)  
          
+
          闭包表达式语法
+closure-expression → { closure-signature opt statements }
+closure-signature → parameter-clause function-result opt in
+closure-signature → identifier-list function-result opt in
+closure-signature → capture-list parameter-clause function-result opt in
+closure-signature → capture-list identifier-list function-result opt in
+closure-signature → capture-list in
+capture-list → [ capture-specifier expression ]
+capture-specifier → weak | unowned | unowned(safe) | unowned(unsafe)
          
 
          
 
          
 
 
          
-
          隐式成员表达式语法
          implicit-member-expression → . identifier  
          
+
          隐式成员表达式语法
+implicit-member-expression → . identifier
          
 
          
 
          
 
 
          
-
          带圆括号的表达式语法
          parenthesized-expression → ( expression-element-list opt )
          expression-element-list → expression-element | expression-element , expression-element-list
          expression-element → expression | identifier : expression  
          
+
          带圆括号的表达式语法
+parenthesized-expression → ( expression-element-list opt )
+expression-element-list → expression-element | expression-element , expression-element-list
+expression-element → expression | identifier : expression
          
 
          
 
          
 
 
          
-
          通配符表达式语法
          wildcard-expression → _  
          
+
          通配符表达式语法
+wildcard-expression → _
          
 
          
 
          
 
 
          
-
          后缀表达式语法
          postfix-expression → primary-expression
          postfix-expression → postfix-expression postfix-operator
          postfix-expression → function-call-expression
          postfix-expression → initializer-expression
          postfix-expression → explicit-member-expression
          postfix-expression → postfix-self-expression
          postfix-expression → dynamic-type-expression
          postfix-expression → subscript-expression
          postfix-expression → forced-value-expression
          postfix-expression → optional-chaining-expression  
          
+
          后缀表达式语法
+postfix-expression → primary-expression
+postfix-expression → postfix-expression postfix-operator
+postfix-expression → function-call-expression
+postfix-expression → initializer-expression
+postfix-expression → explicit-member-expression
+postfix-expression → postfix-self-expression
+postfix-expression → dynamic-type-expression
+postfix-expression → subscript-expression
+postfix-expression → forced-value-expression
+postfix-expression → optional-chaining-expression
          
 
          
 
          
 
 
          
-
          函数调用表达式语法
          function-call-expression → postfix-expression parenthesized-expression
          function-call-expression → postfix-expression parenthesized-expression opt trailing-closure
          trailing-closure → closure-expression  
          
+
          函数调用表达式语法
+function-call-expression → postfix-expression parenthesized-expression
+function-call-expression → postfix-expression parenthesized-expression opt trailing-closure
+trailing-closure → closure-expression
          
 
          
 
          
 
 
          
-
          初始化表达式语法
          initializer-expression → postfix-expression . init  
          
+
          初始化表达式语法
+initializer-expression → postfix-expression . init
          
 
          
 
          
 
 
          
-
          显式成员表达式语法
          explicit-member-expression → postfix-expression . decimal-digit
          explicit-member-expression → postfix-expression . identifier generic-argument-clause opt  
          
+
          显式成员表达式语法
+explicit-member-expression → postfix-expression . decimal-digit
+explicit-member-expression → postfix-expression . identifier generic-argument-clause opt
          
 
          
 
          
 
 
          
-
          Self 表达式语法
          postfix-self-expression → postfix-expression . self  
          
+
          Self 表达式语法
+postfix-self-expression → postfix-expression . self
          
 
          
 
          
 
 
          
-
          动态类型表达式语法
          dynamic-type-expression → postfix-expression . dynamicType  
          
+
          动态类型表达式语法
+dynamic-type-expression → postfix-expression . dynamicType
          
 
          
 
          
 
 
          
-
          附属脚本表达式语法
          subscript-expression → postfix-expression [ expression-list ]  
          
+
          附属脚本表达式语法
+subscript-expression → postfix-expression [ expression-list ]
          
 
          
 
          
 
 
          
-
          Forced-value 表达式语法
          forced-value-expression → postfix-expression !  
          
+
          Forced-value 表达式语法
+forced-value-expression → postfix-expression !
          
 
          
 
          
 
 
          
-
          可选链表达式语法
          optional-chaining-expression → postfix-expression ?  
          
+
          可选链表达式语法
+optional-chaining-expression → postfix-expression ?
          
 
          
-
          
+
          
 
          词法结构
          
 
          
-
          标识符语法
          identifier → identifier-head identifier-characters opt
          identifier → ` identifier-head identifier-characters opt `
          identifier → implicit-parameter-name
          identifier-list → identifier | identifier , identifier-list
          identifier-head → Upper- or lowercase letter A through Z
          identifier-head → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
          identifier-head → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
          identifier-head → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
          identifier-head → U+1E00–U+1FFF
          identifier-head → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
          identifier-head → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
          identifier-head → U+2C00–U+2DFF or U+2E80–U+2FFF
          identifier-head → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
          identifier-head → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
          identifier-head → U+FE47–U+FFFD
          identifier-head → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
          identifier-head → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
          identifier-head → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
          identifier-head → U+D0000–U+DFFFD or U+E0000–U+EFFFD
          identifier-character → Digit 0 through 9
          identifier-character → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
          identifier-character → identifier-head
          identifier-characters → identifier-character identifier-characters opt
          implicit-parameter-name → $ decimal-digits  
          
+
          标识符语法
+identifier → identifier-head identifier-characters opt
+identifier → ` identifier-head identifier-characters opt `
+identifier → implicit-parameter-name
+identifier-list → identifier | identifier , identifier-list
+identifier-head → Upper- or lowercase letter A through Z
+identifier-head → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
+identifier-head → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
+identifier-head → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
+identifier-head → U+1E00–U+1FFF
+identifier-head → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
+identifier-head → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
+identifier-head → U+2C00–U+2DFF or U+2E80–U+2FFF
+identifier-head → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
+identifier-head → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
+identifier-head → U+FE47–U+FFFD
+identifier-head → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
+identifier-head → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
+identifier-head → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
+identifier-head → U+D0000–U+DFFFD or U+E0000–U+EFFFD
+identifier-character → Digit 0 through 9
+identifier-character → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
+identifier-character → identifier-head
+identifier-characters → identifier-character identifier-characters opt
+implicit-parameter-name → $ decimal-digits
          
 
          
 
          
 
 
          
-
          字面量语法
          literal → integer-literal | floating-point-literal | string-literal  
          
+
          字面量语法
+literal → integer-literal | floating-point-literal | string-literal
          
 
          
 
          
 
 
          
-
          整形字面量语法
          integer-literal → binary-literal
          integer-literal → octal-literal
          integer-literal → decimal-literal
          integer-literal → hexadecimal-literal
          binary-literal → 0b binary-digit binary-literal-characters opt
          binary-digit → Digit 0 or 1
          binary-literal-character → binary-digit | _
          binary-literal-characters → binary-literal-character binary-literal-characters opt
          octal-literal → 0o octal-digit octal-literal-characters opt
          octal-digit → Digit 0 through 7
          octal-literal-character → octal-digit | _
          octal-literal-characters → octal-literal-character octal-literal-characters opt
          decimal-literal → decimal-digit decimal-literal-characters opt
          decimal-digit → Digit 0 through 9
          decimal-digits → decimal-digit decimal-digits opt
          decimal-literal-character → decimal-digit | _
          decimal-literal-characters → decimal-literal-character decimal-literal-characters opt
          hexadecimal-literal → 0x hexadecimal-digit hexadecimal-literal-characters opt
          hexadecimal-digit → Digit 0 through 9, a through f, or A through F
          hexadecimal-literal-character → hexadecimal-digit | _
          hexadecimal-literal-characters → hexadecimal-literal-character hexadecimal-literal-characters opt  
          
+
          整形字面量语法
+integer-literal → binary-literal
+integer-literal → octal-literal
+integer-literal → decimal-literal
+integer-literal → hexadecimal-literal
+binary-literal → 0b binary-digit binary-literal-characters opt
+binary-digit → Digit 0 or 1
+binary-literal-character → binary-digit | _
+binary-literal-characters → binary-literal-character binary-literal-characters opt
+octal-literal → 0o octal-digit octal-literal-characters opt
+octal-digit → Digit 0 through 7
+octal-literal-character → octal-digit | _
+octal-literal-characters → octal-literal-character octal-literal-characters opt
+decimal-literal → decimal-digit decimal-literal-characters opt
+decimal-digit → Digit 0 through 9
+decimal-digits → decimal-digit decimal-digits opt
+decimal-literal-character → decimal-digit | _
+decimal-literal-characters → decimal-literal-character decimal-literal-characters opt
+hexadecimal-literal → 0x hexadecimal-digit hexadecimal-literal-characters opt
+hexadecimal-digit → Digit 0 through 9, a through f, or A through F
+hexadecimal-literal-character → hexadecimal-digit | _
+hexadecimal-literal-characters → hexadecimal-literal-character hexadecimal-literal-characters opt
          
 
          
 
          
 
 
          
-
          浮点型字面量语法
          floating-point-literal → decimal-literal decimal-fraction opt decimal-exponent opt
          floating-point-literal → hexadecimal-literal hexadecimal-fraction opt hexadecimal-exponent
          decimal-fraction → . decimal-literal
          decimal-exponent → floating-point-e sign opt decimal-literal
          hexadecimal-fraction → . hexadecimal-literal opt
          hexadecimal-exponent → floating-point-p sign opt hexadecimal-literal
          floating-point-e → e | E
          floating-point-p → p | P
          sign → + | -  
          
+
          浮点型字面量语法
+floating-point-literal → decimal-literal decimal-fraction opt decimal-exponent opt
+floating-point-literal → hexadecimal-literal hexadecimal-fraction opt hexadecimal-exponent
+decimal-fraction → . decimal-literal
+decimal-exponent → floating-point-e sign opt decimal-literal
+hexadecimal-fraction → . hexadecimal-literal opt
+hexadecimal-exponent → floating-point-p sign opt hexadecimal-literal
+floating-point-e → e | E
+floating-point-p → p | P
+sign → + | -
          
 
          
 
          
 
 
          
-
          字符型字面量语法
          string-literal → " quoted-text "
          quoted-text → quoted-text-item quoted-text opt
          quoted-text-item → escaped-character
          quoted-text-item → ( expression )
          quoted-text-item → Any Unicode extended grapheme cluster except "­, \­, U+000A, or U+000D
          escaped-character → \0 | \ | \t | \n | \r | \" | \'
          escaped-character → \x hexadecimal-digit hexadecimal-digit
          escaped-character → \u hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
          escaped-character → \U hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit  
          
+
          字符型字面量语法
+string-literal → " quoted-text "
+quoted-text → quoted-text-item quoted-text opt
+quoted-text-item → escaped-character
+quoted-text-item → ( expression )
+quoted-text-item → Any Unicode extended grapheme cluster except "­, \­, U+000A, or U+000D
+escaped-character → \0 | \ | \t | \n | \r | \" | \'
+escaped-character → \x hexadecimal-digit hexadecimal-digit
+escaped-character → \u hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
+escaped-character → \U hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit
          
 
          
 
          
 
 
          
-
          运算符语法语法
          operator → operator-character operator opt
          operator-character → / | = | - | + | ! | * | % | < | > | & | | | ^ | ~ | .
          binary-operator → operator
          prefix-operator → operator
          postfix-operator → operator  
          
+
          运算符语法语法
+operator → operator-character operator opt
+operator-character → / | = | - | + | ! | * | % | < | > | & | | | ^ | ~ | .
+binary-operator → operator
+prefix-operator → operator
+postfix-operator → operator
          
 
          
-
          
+
          
 
          类型
          
 
          
-
          类型语法
          type → array-type | function-type | type-identifier | tuple-type | optional-type | implicitly-unwrapped-optional-type | protocol-composition-type | metatype-type  
          
+
          类型语法
+type → array-type | function-type | type-identifier | tuple-type | optional-type | implicitly-unwrapped-optional-type | protocol-composition-type | metatype-type
          
 
          
 
          
 
 
          
-
          类型标注语法
          type-annotation → : attributes opt type  
          
+
          类型标注语法
+type-annotation → : attributes opt type
          
 
          
 
          
 
 
          
-
          类型标识语法
          type-identifier → type-name generic-argument-clause opt | type-name generic-argument-clause opt . type-identifier
          type-name → identifier  
          
+
          类型标识语法
+type-identifier → type-name generic-argument-clause opt | type-name generic-argument-clause opt . type-identifier
+type-name → identifier
          
 
          
 
          
 
 
          
-
          元组类型语法
          tuple-type → ( tuple-type-body opt )
          tuple-type-body → tuple-type-element-list ... opt
          tuple-type-element-list → tuple-type-element | tuple-type-element , tuple-type-element-list
          tuple-type-element → attributes opt inout opt type | inout opt element-name type-annotation
          element-name → identifier  
          
+
          元组类型语法
+tuple-type → ( tuple-type-body opt )
+tuple-type-body → tuple-type-element-list ... opt
+tuple-type-element-list → tuple-type-element | tuple-type-element , tuple-type-element-list
+tuple-type-element → attributes opt inout opt type | inout opt element-name type-annotation
+element-name → identifier
          
 
          
 
          
 
 
          
-
          函数类型语法
          function-type → type -> type  
          
+
          函数类型语法
+function-type → type -> type
          
 
          
 
          
 
 
          
-
          数组类型语法
          array-type → type [ ] | array-type [ ]  
          
+
          数组类型语法
+array-type → type [ ] | array-type [ ]
          
 
          
 
          
 
 
          
-
          可选类型语法
          optional-type → type ?  
          
+
          可选类型语法
+optional-type → type ?
          
 
          
 
          
 
 
          
-
          隐式解析可选类型语法
          implicitly-unwrapped-optional-type → type !  
          
+
          隐式解析可选类型语法
+implicitly-unwrapped-optional-type → type !
          
 
          
 
          
 
 
          
-
          协议合成类型语法
          protocol-composition-type → protocol < protocol-identifier-list opt >
          protocol-identifier-list → protocol-identifier | protocol-identifier , protocol-identifier-list
          protocol-identifier → type-identifier  
          
+
          协议合成类型语法
+protocol-composition-type → protocol < protocol-identifier-list opt >
+protocol-identifier-list → protocol-identifier | protocol-identifier , protocol-identifier-list
+protocol-identifier → type-identifier
          
 
          
 
          
 
 
          
-
          元类型语法
          metatype-type → type . Type | type . Protocol  
          
+
          元类型语法
+metatype-type → type . Type | type . Protocol
          
 
          
 
          
 
 
          
-
          类型继承子句语法
          type-inheritance-clause → : type-inheritance-list
          type-inheritance-list → type-identifier | type-identifier , type-inheritance-list
          
+
          类型继承子句语法
+type-inheritance-clause → : type-inheritance-list
+type-inheritance-list → type-identifier | type-identifier , type-inheritance-list
          
 
          
 
                     
@@ -1083,6 +1454,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/10_Statements.html b/chapter3/10_Statements.html
index 12c6eeec..05fa7ebd 100644
--- a/chapter3/10_Statements.html
+++ b/chapter3/10_Statements.html
@@ -5,12 +5,12 @@
         
         
         
-        语句 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
          
+    
          
     
          
     
     
@@ -98,7 +98,7 @@
     
     
          
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
          
 
          
 
@@ -119,7 +119,7 @@
         
 
         
        • 
-             Introduction
+             序
         
          • 
         
     
@@ -331,7 +331,7 @@
         
        • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -587,10 +587,21 @@
 
                 
          
                 
-                    
          
+                    
          
                     
-                        
          语句
          
+                        
          
+
          翻译：coverxit
          
+
          校对：numbbbbb
          
+
          
+
          语句
          
 
          
+
          本页包含内容：
          
+
 
          在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式和声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。
          
 
          循环语句用于重复执行代码块；分支语句用于执行满足特定条件的代码块；控制传递语句则用于修改代码的执行顺序。在稍后的叙述中，将会详细地介绍每一种类型的控制流语句。
          
 
          是否将分号(;)添加到语句的结尾处是可选的。但若要在同一行内写多条独立语句，请务必使用分号。
          
@@ -604,6 +615,7 @@
 
          statement → control-transfer-statement; opt
          
 
          statement → statment statements; opt
          
 
+
          
 
          循环语句
          
 
          取决于特定的循环条件，循环语句允许重复执行代码块。Swift 提供四种类型的循环语句：for语句、for-in语句、while语句和do-while语句。
          
 
          通过break语句和continue语句可以改变循环语句的控制流。有关这两条语句，请参考Break 语句和Continue 语句。
          
@@ -692,8 +704,9 @@
 
          condition表达式的值的类型必须遵循LogicValue协议。同时，condition表达式也可以使用可选绑定，请参考可选绑定待添加链接。
          
 
          
 
          GRAMMAR OF A DO-WHILE STATEMENT
          
-
          do-while-statement → do code-block while while-condition 
          
+
          do-while-statement → do code-block while while-condition
          
 
          
+
          
 
          分支语句
          
 
          取决于一个或者多个条件的值，分支语句允许程序执行指定部分的代码。显然，分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句：if语句和switch语句。
          
 
          switch语句中的控制流可以用break语句修改，请参考Break 语句。
          
@@ -774,7 +787,8 @@ else {
 
          guard-clause → where guard-expression
          
 
          guard-expression → expression
          
 
-
          带标签的语句
          
+
          
+ 带标签的语句
          
 
          你可以在循环语句或switch语句前面加上标签，它由标签名和紧随其后的冒号(:)组成。在break和continue后面跟上标签名可以显式地在循环语句或switch语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，请参考Break 语句和Continue 语句。
          
 
          标签的作用域是该标签所标记的语句之后的所有语句。你可以不使用带标签的语句，但只要使用它，标签名就必唯一。
          
 
          关于使用带标签的语句的例子，请参考控制流一章的带标签的语句待添加链接。
          
@@ -888,6 +902,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/chapter3/chapter3.html b/chapter3/chapter3.html
index c855d9c8..62a9febf 100644
--- a/chapter3/chapter3.html
+++ b/chapter3/chapter3.html
@@ -5,12 +5,12 @@
         
         
         
-        语言参考 | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -21,8 +21,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -46,7 +46,7 @@
 
 
         
-    
          
+    
          
     
          
     
     
@@ -98,7 +98,7 @@
     
     
          
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
          
 
          
 
@@ -119,7 +119,7 @@
         
 
         
        • 
-             Introduction
+             序
         
          • 
         
     
@@ -331,7 +331,7 @@
         
        • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -534,7 +534,7 @@
     
         
     
-        
+        
     
         
     
@@ -628,6 +628,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/gitbook/jsrepl/sandbox.html b/gitbook/jsrepl/sandbox.html
index ad2dd2ec..21a351cc 100755
--- a/gitbook/jsrepl/sandbox.html
+++ b/gitbook/jsrepl/sandbox.html
@@ -2,9 +2,18 @@
   allowtransparency="true" frameborder="0" scrolling="0" width="170" height="30">
          • TYPE html>
 
   
-   jsREPL Sandbox
+   《The Swift Programming Language》中文版
   
   
      
-  
+  
+序yle="margin-left:15%;"> 
          • TYPE html>
+
+  
+   《The Swift Programming Language》中文版
+  
+  
+     
+  
 
diff --git a/index.html b/index.html
index 6e76d9e1..061f31a4 100644
--- a/index.html
+++ b/index.html
@@ -5,12 +5,12 @@
         
         
         
-        Introduction | Swift 编程语言
+        《The Swift Programming Language》中文版
 
         
         
         
-        
+        
         
         
 
@@ -19,8 +19,8 @@
         
         
 
-        
-        
+        
+        
         
         
 
@@ -44,7 +44,7 @@
 
 
         
-    
          
+    
          
     
          
     
     
@@ -96,7 +96,7 @@
     
     
          
         
-        Swift 编程语言
+        这一次，让中国和世界同步
     
          
 
          
 
@@ -117,7 +117,7 @@
         
 
         
        • 
-             Introduction
+             序
         
          • 
         
     
@@ -329,7 +329,7 @@
         
        • 
             
             
-                 2.19. 嵌套类型
+                 2.19. 类型嵌套
             
             
             
@@ -532,7 +532,7 @@
     
         
     
-        
+        
     
         
     
@@ -585,14 +585,64 @@
 
                 
          
                 
-                    
          
+                    
          
                     
-                        
          Swift 编程语言
          
-
          Swift 是苹果在 WWDC 2014 上发布的一款全新的编程语言，本书译自苹果官方的 Swift 教程《The Swift Programming Language》。
          
-
          翻译正在进行中，翻译完成的部分会实时同步到这里。您可以到项目首页查看当前进度。
          
-
          由于是多人协同翻译，可能会有些术语或者句子翻译不太恰当，如果您在阅读过程中发现此类问题，请直接给我们提 issue 或者 pull request。翻译完成后我们会进行认真的校对，给大家提供一本高质量的 Swift 教程。
          
-
          如果您愿意加入进来，帮助我们进行翻译和校对，请阅读项目首页中的说明并加入QQ群：364279588，我们期待您的加入，在 Swift 的历史上留下您的足迹！
          
-
          最后，非常感谢您的阅读，如果您觉得本文不错的话请分享给其他人，您的支持就是我们最大的动力！
          
+                        
          
+
          Swift 中文翻译组：364279588（要求对翻译感兴趣）
          
+
          Swift 兴趣交流群：307017261
          
+
          Swift 开发者社区
          
+
          
+
          
+
          
+
          如果你觉得这个项目不错，请点击Star一下，您的支持我们最大的动力。
          
+
          
+
          这一次，让中国和世界同步
          
+
          现在是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
            • 
+
          • coverxit
            • 
+
          • wh1100717
            • 
+
          • TimothyYe
            • 
+
          • honghaoz
            • 
+
          • Hawstein
            • 
+
          • JaySurplus
            • 
+
          • stanzhai
            • 
+
          • lyuka
            • 
+
          • geek5nan
            • 
+
          • xielingwang
            • 
+
          • yankuangshi
            • 
+
          • dabing1022
            • 
+
          • siemenliu
            • 
+
          • fd5788
            • 
+
          • youkugems
            • 
+
          • haolloyin
            • 
+
          • superkam
            • 
+
          • vclwei
            • 
+
          • sg552
            • 
+
          • bzsy
            • 
+
          • pyanfield
            • 
+
          • ericzyh
            • 
+
          • 088haizi
            • 
+
          • viztor
            • 
+
          • pp-prog
            • 
+
          • baocaixiong
            • 
+
          • marsprince
            • 
+
          • shinyzhu
            • 
+
          • happyming
            • 
+
          • menlongsheng
            • 
+
          • zq54zquan
            • 
+
          • Evilcome
            • 
+
          • lslxdx
            • 
+
          • yeahdongcn
            • 
+
          
 
                     
                     
          
@@ -636,6 +686,6 @@ require(["gitbook"], function(gitbook) {
 
 
         
-    
+    
     
 
diff --git a/manifest.appcache b/manifest.appcache
index 66aee5dc..17f7d75e 100644
--- a/manifest.appcache
+++ b/manifest.appcache
@@ -1,10 +1,10 @@
 CACHE MANIFEST
-# Revision 1402493167135
+# Revision 1402523087599
 
 CACHE:
 index.html
-chapter1/02_a_swift_tour.html
 chapter1/01_swift.html
+chapter1/02_a_swift_tour.html
 chapter1/chapter1.html
 chapter2/13_Inheritance.html
 chapter2/01_The_Basics.html
@@ -38,9 +38,9 @@ chapter3/05_Declarations.html
 chapter3/02_Lexical_Structure.html
 chapter3/07_Patterns.html
 chapter3/08_Generic_Parameters_and_Arguments.html
+chapter3/09_Summary_of_the_Grammar.html
 chapter3/10_Statements.html
 chapter3/chapter3.html
-chapter3/09_Summary_of_the_Grammar.html
 gitbook/app.js
 gitbook/fonts/anonymouspro/400.woff
 gitbook/fonts/anonymouspro/400i.woff
diff --git a/search_index.json b/search_index.json
index 6302f04b..1c6afa65 100644
--- a/search_index.json
+++ b/search_index.json
@@ -1 +1 @@
-{"version":"0.5.2","fields":[{"name":"title","boost":10},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"index.html#gitbook_101":["2014","issu","languag","program","pull","qq群：364279588","request","swift","undefinedundefin","wwdc"],"chapter1/02_a_swift_tour.html#gitbook_102":["0","0..3","0..time","0.0","1","10","100","103","11","12","13","16","19","2","2.5","20","25","3","3.0","3.1","3.59","3.69","3.79","4","42","43","5","5.2","50","597","69105","7","7.simpledescript","70","70.0","75","8","87","8:09","9","9.9","94","a.adjust","a.simpledescript","ac","ace.toraw","acerawvalu","add","addon","addone(numb","adescript","adjust","amount","anoth","anotherproperti","ant","anycommonel","anycommonelements([1","appl","applese","applesummari","area","b","b.adjust","b.simpledescript","bdescript","blue","bool","bottl","c","captain","card","card(rank","card添加一个方法，创建一副完整的扑克牌并把每张牌的rank和suit","case","catfish","celeri","chees","class","club","condit","condition(item","convertedrank","convertedrank.simpledescript","count","counter","counter.incrementby(2","cucumb","dai","default","deinit","diamond","dictionary(item","result","result(str","result(sunris","return","returnfifteen","rh","rhsitem","sandwich","score","secondforloop","see","self","self.nam","self.sidelength","self被用来区别实例变量。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都需要赋值——无论是通过声明（就像numberofsides）还是通过构造器（就像nam","sequenc","serverrespons","serverresponse.error(\"out","serverresponse.result(\"6:00","serverresponse和switch","set","setter","seven","shape","shape.numberofsid","shape.simpledescript","shapedescript","shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用init","shoppinglist","shoppinglist[1","side","sidelength","simpl","simpleclass","simpledescript","simplestructur","simplestructure时候mutating关键字用来标记一个会修改结构体的方法。simpleclass","six","size","some(100","some(t","sort([1","soup","spade","spici","squar","square(sidelength","square.sidelength","standard","string","string(self.toraw","string(width","struct","structur","success","suit","suit.heart","suit.simpledescript","suit添加一个color方法，对spades和clubs返回“black”，对hearts和diamonds返回“r","sum","sumof","sumof(42","sumof(numb","sunris","sunset","super.init(nam","swift","switch","switch中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句结尾写break","t","t.generatortype.el","tast","tea","teamscor","ten","test","test.area","test.simpledescript","three","threedescript","threeofspad","threeofspades.simpledescript","threeofspadesdescript","time","todai","toraw和fromraw","triagl","triangl","triangle.perimet","triangle.sidelength","triangleandsquar","triangleandsquare(s","triangleandsquare.squar","triangleandsquare.square.sidelength","triangleandsquare.triangle.sidelength","true","tuesdai","tulip","two","type","u","u.generatortype.el","uncom","undefinedundefin","var","veget","vegetablecom","veri","water","watercress","where，只在冒号后面写接口或者类名。<t","width","widthlabel","willset","willset和didset","world","x","x.hassuffix(\"pepp","xcode","y"],"chapter1/01_swift.html#gitbook_104":["arc","automat","c","cocoa","cocoa的基础上构建框架栈并将其标准化。objective-c","count","c的兼容性的限制。swift","foundat","hello","io","objective-c","os","refer","swift","touch","undefinedundefin","world","x"],"chapter1/chapter1.html#gitbook_106":["swift","undefinedundefin"],"chapter2/13_Inheritance.html#gitbook_107":["0","0.0","0和maxpasseng","1","10.0","2","35.0","4","40.0","5","60.0","automat","automatic.descript","automatic.spe","automaticcar","automaticcar的speed属性，属性的didset观察器就会自动地设置gear属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位gear的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4","automaticcar，它是car的子类。automaticcar表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。automaticcar也提供了定制的descript","bicycl","bicycle.descript","bicycle。这个新类是在vehicle类的基础上创建起来。因此你需要将vehicle类放在bicycl","bicycle不仅可以继承vehicle的属性，还可以继承它的方法。如果你创建了一个bicycle类的实例，你就可以调用它继承来的descript","bicycle是vehicle的子类，vehicle是bicycle的超类。新的bicycle类自动获得vehicle类的特性，比如maxpassengers和numberofwheels属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述bicycl","bicycle的一个子类：双人自行车（tandem）。tandem从bicycle继承了两个属性，而这两个属性是bicycle从vehicle继承而来的。tandem并不修改轮子的数量，因为它仍是一辆自行车，有2个轮子。但它需要修改maxpasseng","bicycle类定义了一个初始化器来设置它定制的特性（自行车只有2个轮子）。bicycle的初始化器调用了它父类vehicle的初始化器super.init()，以此确保在bicycle类试图修改那些继承来的属性前，vehicl","bicycle，它继承了vehicl","car","car.descript","car中的description方法并非完全自定义，而是通过super.description使用了超类vehicle中的descript","car声明了一个新的存储型属性speed，它是double类型的，默认值是0.0，表示“时速是0英里”。'car'有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4","car的新实例，并打印descript","car重写了继承来的description方法，它的声明与vehicle中的description方法一致，声明前面加上了overrid","class","class前添加@final特性（@fin","class）来将整个类标记为fin","definit","descript","didset","doubl","final","final方法，属性或下标，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标也可以在扩展的定义里标记为fin","final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@fin","func","gear","getters和sett","getter和sett","getter（或sett","goe","here","init","initi","instanc","int","int(spe","limitedcar","limitedcar.descript","limitedcar.spe","maxpasseng","method），实例属性（inst","method），类方法（class","min(newvalu","mph","numberofwheel","objective-c，在swift","observ","observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stor","overrid","override关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少overrid","override关键字会提醒swift","passeng","perform","println(\"automaticcar","println(\"bicycl","println(\"car","println(\"speedlimitedcar","println(\"tandem","properti","property）还是计算型属性（comput","property），或下标（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overrid","return","set","setter，那么你也一定要提供getter。如果你不想在重写版本中的getter里修改继承来的属性值，你可以直接返回super.someproperty来返回继承来的值。正如下面的speedlimitedcar","someclass","somemethod的重写实现中，可以通过super.somemethod()来调用超类版本的somemethod","someproperty的getter或setter的重写实现中，可以通过super.someproperty来访问超类版本的someproperti","somesuperclass","somevehicl","speed","speedlimitedcar","speedlimitedcar实例的speed属性时，属性setter的实现会去检查新值与限制值40mph的大小，它会将超类的speed设置为newvalue和40.0中较小的那个。这两个值哪个较小由min函数决定，它是swift标准库中的一个全局函数。min","speedlimitedcar实例的speed属性设置为一个大于40mph的数，然后打印description函数的输出，你会发现速度被限制在40mph","speedlimitedcar，它是car的子类。类speedlimitedcar表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的spe","string","subclass","subclassing（子类化？待定）重写（overriding）访问超类的方法，属性及下标重写方法重写属性重写属性的getters和setters重写属性观察器（properti","subscript","super","super.descript","super.init","super.spe","super[someindex","swift","swift中，类可以调用和访问超类的方法，属性和下标，并且可以重写（override）这些方法，属性和下标来优化或修改它们的行为。swift","tandem","tandem.descript","tandem类也继承了descript","travel","undefinedundefin","up","var","vehicl","vehicle的一个新的子类，叫car，它重写了从vehicle类继承来的'description'","vehicle的基类。这个基类声明了两个对所有车辆都通用的属性（numberofwheels和maxpassengers）。这些属性在description方法中使用，这个方法返回一个str","vehicle类中maxpassengers的默认值对自行车来说已经是正确的，因此在bicycle的初始化器中并没有改变它。而numberofwheels原来的值对自行车来说是不正确的，因此在初始化器中将它更改为2","vehicle类定义了初始化器（initi","vehicle类的初始化器为任意的一辆车设置一些初始化属性值（numberofwheel","wheel","willset或didset实现是不恰当。此外还要注意，你不可以同时提供重写的setter和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的setter，那么你在sett"],"chapter2/01_The_Basics.html#gitbook_109":["0","0.0","0.0125","0.14159","000123.456","0b","0b10001","0o","0o21","0x","0x11","0xc.3p0","0xfp-2","0xfp2","0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点原始值还有一个可选的指数，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p","0为fals","0为true的时候代码运行才会继续，也就是说，当age的值非负的时候。如果age的值是负数，就像代码中那样，ag","1","1.21875e1","1.25","1.25e-2","1.25e2","10","10^-2","10^2","12.1875","123","125.0","15","17","1_000_000","1_000_000.000_000_1","1的比较结果是bool类型，所以第二个例子可以通过类型检查。类似i","200","255","2^-2","2^2","2_000","3","3.14159","3.14159，0.1和-273.15","3.75","32位平台上，int和int32","32位平台上，uint和uint32","3可以直接和原始值0.14159","3没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为doubl","4.75会变成4，-3.9会变成-3","404","42","42和-23","42和3.14159","42并且没有标明类型，swift","60.0","64位平台上，int和int64","64位平台上，uint和uint64","8、16、32和64","8位无符号整数类型是uint8，32位有符号整数类型是int32","_","actualnumb","actualnumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualnumb","ag","anotherpi","array和dictionari","assert(ag","assert函数来写一个断言。给assert函数传入一个结果为true或者false的表达式以及一条信息，当表达式为fals","assumedstr","audiosampl","audiosample.min","audiosample被定义为uint16的一个别名。因为它是别名，audiosample.min实际上是uint16.min，所以会给maxamplitudefound赋一个初值0","binaryinteg","bonjour","bool","bool。布尔值是指逻辑，因为它们只能是真或者假。swift","bool类型的地方使用了非布尔值，swift","c","cannotbeneg","cat","chang","cocoa里的nslog函数一样，println","code","comment","compile-tim","constantnam","convert","convertednumb","current","currentloginattempt","decimaldoubl","decimalinteg","definitestr","descript","dogcow","doubl","double(thre","double或者float","double精确度很高，至少有15位数字，而float最少只有6","double而不是float","double表示64","end","error","eww","exponentdoubl","exp，那这个数相当于基数和10^exp","exp，那这个数相当于基数和2^exp","fals","first","float表示32","found","found"","found")元组把一个int值和一个str","friendlywelcom","friendlywelcome的值从"hello!"改为了"bonjour!"","gt","hello","hexadecimaldoubl","hexadecimalinteg","horribl","http","http200statu","http200status.descript","http200status.statuscod","http404error","http404error.0","http404error.1","if和while语句中来对可选的值进行判断并把值赋给一个常量或者变量。if和whil","if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是fals","if语句的第一个分支中操作actualnumber的值，你可以改成if","implicitli","int","int(pi","int)或者(str","int8","int8.max","int8类型的常量或者变量可以存储的数字范围是-128~127，uint8类型的常量或者变量能存储的数字范围是0~255","integ","integerpi","interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，swift会用当前常量或变量的值替换这些占位符。将常量或变量名放入反斜杠符加一对圆括号中"\\()"","intuint浮点数类型安全和类型推测数值类原始值数值类型转换整数转换整数和浮点数转换类型别名布尔值元组可选if","int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，int可以存储的整数范围也可以达到-2147483648~2147483647","int是整型；double和float是浮点型；bool是布尔型；string是字符串。swift","int类型更大或者更小的数字。swift","io","justoveronemillion","justthestatuscod","languagenam","less","let来声明常量，用var","line","maxamplitudefound","maximumnumberofloginattempt","maximumnumberofloginattempts或者welcomemessage）和一个指定类型的值（比如数字10或者字符串hello","maximumnumberofloginattempts的新常量，并给它一个值10。然后，声明一个名字是currentloginattempt的变量并将它的值初始化为0","maxvalu","meaningoflif","messag","minvalu","min和max","multilin","multipl","nest","nil","nil不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为nil","nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil","nil，nil","nil，但是后面的代码运行需要一个非nil","now","nsnotfound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，swift","objc","objective-c","octalinteg","ok","on","onemillion","option","orangesareorang","orangesareorange和turnipsaredelicious的类型会被推测为bool，因为它们的初值是布尔原始值。就像之前提到的int和double一样，如果你创建变量的时候给它们赋值true或者false，那你不需要给常量或者变量标明bool","os","over","paddeddoubl","person'","pi","pointonefouronefivenin","possiblenumb","possiblenumber.toint","possiblenumber.toint返回的可选int包含一个值，创建一个叫做actualnumb","possiblestr","print","println","println(\"\\(possiblenumb","println(\"eww","println(\"mmm","println(\"th","println(\"thi","println(assumedstr","println(cat","println(definitestr","println(friendlywelcom","println(possiblestr","println函数输出传入的str","println是一个用来输出的全局函数，输出的内容会在最后带换行。如果你用xcode，println将会输出内容到“console”面板上。(另一种函数叫print","properti","quot;an","quot;not","refer","second","serverresponsecod","someopt","sometype(ofinitialvalu","start","statement","statu","statuscod","statusmessag","string","string."","string”的意思是“可以存储任意str","string和隐式解析可选str","string类型有一个叫做toint的方法，作用是将一个string值转换成一个int值。然而，并不是所有的字符串都可以转换成一个整数。字符串"123"可以被转换成数字123，但是字符串"hello","string，你绝对不可能不小心传进去一个int","string，名字为welcomemessag","string，类型安全会阻止你不小心传入一个int","subscript","surveyansw","swift","swift可以推断出这个常量或者变量的类型，详情参见类型安全和类型推断(待添加链接)。在上面的例子中，没有给welcomemessag","swift用字符串插值（str","tasti","three","three的值被用来创建一个doubl","toint方法可能会失败，所以它返回一个可选的int，而不是一个int。一个可选的int被写作int?而不是int。问号暗示包含的值是可选，也就是说可能包含int值也可能不包含值。（不能包含其他任何值比如bool值或者string值。只能是int","toint方法来尝试将一个string转换成int","toobig","true","true。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为true，代码运行会继续进行；如果条件判断为fals","true和fals","tupl","turnip","turnipsaredelici","twothousand","twothousandandon","twothousand类型是uint16，然而常量one类型是uint8。它们不能直接相加，因为它们类型不同。所以要调用uint16(one)来创建一个新的uint16数字并用on","typealia","uint","uint16","uint16(on","uint16有一个构造器，可以接受一个uint8类型的值，所以这个构造器可以用现有的uint8来创建一个新的uint16。注意，你并不能传入任意类型的值，只能传入uint16","uint16，可以进行相加。目标常量twothousandandone的类型被推测为uint16，因为它是两个uint16","uint8","uint8.max","uint8.min","uint，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用int，即使你要存储的值已知是非负的。统一使用int","undefinedundefin","unicod","unown","unwrap","valu","var","web","welcomemessag","welcomemessage变量添加了类型标注，表示这个变量可以存储str","world"","written","x","xcode","y","z","zero"],"chapter2/03_Strings_and_Characters.html#gitbook_111":["0","0(空字符)、\\\\(反斜线)、\\t(水平制表符)、\\n(换行符)、\\r(回车符)、\\"(双引号)、\\'","1","10","103","111","128054","128054，是一个十六进制1f436","144","159","16","182","2","2.5","21","21位数字(和名称)，例如u+0061表示小写的拉丁字母a","240","3","33","4","40","5","55357","55357)，第二个值为u+dc36","56374","6","68","7.5","8","act","act1scenecount","anoth","anotheremptystr","api","ascii","blackheart","boolean","c","capulet'","carriag","cell","charact","character1","character2","characterpluscharact","characterplusstr","characters(章节信息url","cocoa","codeunit","compar","compile-tim","concaten","constantstr","count","countel","countelements(unusualmenageri","countelements返回的字符数量并不总是与包含相同字符的nsstring的length","d","d``o``g``!和🐶(dog","dog","dogstr","dogstring.unicodescalar","dogstring.utf16","dogstring.utf8","dollarsign","dollarsign、blackheart和sparklingheart","double(multipli","dromedari","empti","emptystr","emptystring.isempti","enumer","equal","error","face字符的utf-16","face的4","face的unicod","face，unicod","for-in","foundat","friar","g","good","great","hall","hasprefix","hasprefix/hassuffix","hello","help","highland","hors","initi","instruct","interpol","isempti","koala","lawrence'","liter","look","loops(章节信息url","lowercas","mansion","messag","morn","multipli","multiplier作为\\(multipli","mutabl","name=\"comparing_strings\">提示hello","paragraph","paragraph变量为nil，打破它持有的htmlelement实例的强引用，htmlel","paragraph变量定义为可选htmlelement，因此我们可以赋值nil","person","person(nam","person?的变量，用来按照代码片段中的顺序，为新的person实例建立多个引用。由于这些变量是被定义为可选类型(person?，而不是person)，它们的值会被自动初始化为nil，目前还不会引用到person","person和apart","person和apartment实例并将类实例赋值给john和number73","person和apartment的例子一致，但是有一个重要的区别。这一次，apartment的ten","person和apartment的例子展示了两个属性的值都允许为nil","person实例依然保持对apartment实例的强引用，但是apartment实例只是对person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向person","person实例有一个类型为string，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apart","person实例现在有了一个指向apartment实例的强引用，而apartment实例也有了一个指向person实例的强引用。因此，当你断开john和number73变量所持有的强引用时，引用计数并不会降为0，实例也不会被arc","person类开始，并定义了一个叫nam","person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。person","person类的新实例被赋值给了reference1变量，所以reference1到person类的新实例之间建立了一个强引用。正是因为这个强引用，arc会保证person","person类的构造函数的时候，"john","print","println(\"\\(country.name)'","println(\"\\(nam","println(\"apart","println(\"card","println(paragraph!.ashtml","prints\"hello","quot","refer","reference)和无主引用(unown","reference1","reference2","reference3","return","self","self.capitalc","self.countri","self.custom","self.nam","self.name)>\\(text)check","class类型。它创建了一个可以存储ani","cocoa","code","come","common","compound","confid","conform","conformance(arrai","equatable类型都可以安全的使用在findindex函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个equat","equatable，也就意味着“任何t类型都遵循equat","equival","error","exampl","exist","extens","extension][6","extension][7","fals","findindex([\"mik","findindex([3.14159","findindex(arrai","findindex中这个单个类型参数写做：t","findindex函数现在则可以成功的编译过，并且作用于任何遵循equatable的类型，如double或str","findindex，用某个类型t","findstringindex","findstringindex(arrai","findstringindex(str","findstringindex的泛型版本findindex。请注意这个函数仍然返回int","findstringindex的非泛型函数，该函数功能是去查找包含一给定string值的数组。若查找到匹配的字符串，findstringindex函数返回该字符串在数组中的索引值（int），反之则返回nil","first","for-in循环和半闭区间操作(..)来迭代somecontainer中的所有items。对于每个item，函数检查是否somecontainer中的item不等于对应的anothercontainer中的item，如果这两个items不等，则这两个容器不匹配，返回fals","for—that","foundindex","fromthetop","func","function","gener","give","goe","guide，即便你没有实现它。例如：swift的array和dictionary类型都是泛型集。你可以创建一个int数组，也可创建一个string数组，或者甚至于可以是任何其他swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(dictionari","hashtabl","hello","here","here’","hierarchi","implement","import","in-out参数交换a和b的值，这两个参数被描述为[in-out类型参数][1","index","indic","inform","inout","inspir","int","intstack","intstack指定了container的实现，适用的itemtype被用作int类型。对于这个contain","intstack类型只能用于int值，不过，其对于定义一个泛型stack","intstack类型实现了container协议的所有三个要求，在intstack","intstack类型的非泛型版本，适用于遵循contain","int索引值下标可以检索到每一个item","int这一行，一切仍旧可以工作，因为它清楚的知道itemtyp","int，将抽象的itemtype类型转换为具体的int","item","items.append(item","items.count","items.removelast","items[i","items。这个需求通过一个类型约束和wher","items的属性，使用空的t","itemtyp","itemtype。th","item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循contain","item的push方法，该参数必须是t","keytyp","languag","last","left","librari","llama","look","made","malcolm","manag","match","method","model","mutat","name","navig","need","nil","note","now","number","option","origin","out","pair","parakeet","paramet","parameters类型参数命名类型参数泛型类型类型约束类型约束语法类型约束行为关联类型关联类型行为扩展一个存在的类型为一指定关联类型wher","part","placehold","pop","popviewcontrolleranim","pop并移除值"cuatro"","pop方法的返回值，该返回值将是一个t","possibl","print","println(\"al","println(\"not","println(\"someint","println(\"th","protocol","provid","provide（这个协议不会定义itemtype是遵循类型所提供的何种信息的别名）。尽管如此，itemtype别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在append方法和下标中的类型，以便保证任何期望的contain","push","push(item","push)/出栈(pop","pushviewcontroller:anim","remov","report","return","same","see","self.push(item","someclass","somecontain","somecontainer.count","somecontainer[i","somecontainer中item","somecontainer中的item","somecontainer和anothercontainer。somecontainer参数是类型c1，anothercontainer参数是类型c2。c1和c2","somecontainer和anothercontainer包含相同的item","somecontainer是一个c1","somefunction(somet","somestr","someu","stack","stack(栈)。一个栈是一系列值域的集合，和array(数组)相似，但其是一个比swift的array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop","stack(inout","swaptwovalues例子中，节点类型t是一种类型参数的示例。类型参数指定并命名为一个节点类型，并且紧随在函数名后面，并用一对尖括号括起来（如)。这个尖括号告诉swift那个t是swaptwovalues函数所定义的一个节点类型。因为t是一个节点，swift不会去查找每一个命名为t","temporarya","terrapin","three","tre","true","type","type-saf","typealia","t分别代表tnt和string","t定义了一个名为“某种类型t”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“t”。在这种情况下，t","t来表示）来代替实际类型名（如int、string或double）。节点类型名并不是表示t必须是任何类型，但是其规定a和b必须是同一类型的t，而不管t表示任何类型。只有swaptwovalues函数在每次调用时所传入的实际类型决定了t","t被用作append方法的item参数和下标的返回类型。swift因此可以推断出被用作这个特定容器的itemtype的t","t，有一个需要t必须是someclass子类的类型约束；第二个类型参数u，有一个需要u必须遵循someprotocol","u","uinavigationcontrol","undefinedundefin","uno","uppercamelcas","us","valu","valuetofind","valuetofind”。不是所有的swift中的类型都可以用等式符(==)进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么swift没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型t","var","variabl","view","whenev","where语句作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置wher","where语句的一部分，写在关键字wher","world"],"chapter2/23_Advanced_Operators.html#gitbook_164":["0","0.0","00000000","00000001","00000100","00001000","00001111","00010000","00010001","00111100","01111111","0b00000101","0b00001111","0b00010100","0b00111111","0b01011110","0b10110010","0b11110000","0b11111100","0x000099","0x0000cc","0x0000ff","0x006600","0x00ff00","0x66","0x99","0xcc","0xcc0000","0xcc6699","0xcc6699和0x0000ff进行按位与运算，得到0x000099，无需向右移位了，所以结果就是0x99，即十进制的153","0xcc6699和0x00ff00的按位操作得到0x006600。然后向右移动8們，得到0x66，即十进制的102","0xcc6699和0xff0000进行按位与&操作就可以得到红色部分。0xff0000中的0了遮盖了oxcc6699的第二和第三个字节，这样6699被忽略了，只留下0xcc0000","0xff0000","0。移位过程中保持符号会不变，负数在接近0","0，代表正数，另外7比特位二进制表示的实际值就刚好是4","0，或者对0","0，负数为1","1","1(11111111向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的0","1(11111111向左移1","1.0","1.0，1.0","100","10000000","102","11110000","11111110","11111111","12","124","127","128","128，即二进制的10000000。用溢出减法减去去1后，变成了01111111，即uint8所能承载的最大整数127","140","15","153","16","16。十六进制中每两个字符是8比特位，所以移动16位的结果是把0xcc0000变成0x0000cc。这和0xcc是相等的，都是十进制的204","1个比特位(称为符号位)来表达这个整数是正数还是负数。0代表正数，1","1位时乘于2，右移1位时除于2","1时才为1","1的条件是两个输入数的同一位不同，如果相同就设为0","1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1","1，代表负数，7个数值位要表达的二进制值是124，即128","2","2.0","2.0，4.0","20","204","240","254","255","2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128","2的整数。向左移动一个整型的比特位相当于把这个数乘于2，向右移一位就是除于2","3","3.0","3.0，1.0","32767","32768","4","4.0","4而不是0。优先级高的运算符要先计算，在swift和c","5","5.0","5.0，5.0","6","6.0","60","66","6699","7","8","8-bit","8.0","99","abov","absolut","accord","achiev","action","actual","ad","add","addit","adopt","advanc","advantag","affect","afterdoubl","afterincr","allow","alreadi","alsoposit","alwai","amp","amp;/和&%进行除0操作时就会得到0","ampersand","anoth","anothertwothre","anothervector","answer","anyth","appear","appli","approach","arithmet","around","art/bitshiftsigned_2x.png","art/bitshiftsignedaddition_2x.png","art/bitshiftsignedfour_2x.png","art/bitshiftsignedminusfour_2x.png","art/bitshiftsignedminusfourvalue_2x.png","art/bitshiftunsigned_2x.png","art/bitwiseand_2x.png","art/bitwisenot_2x.png","art/bitwiseor_2x.png","art/bitwisexor_2x.png","art/overflowaddition_2x.png","art/overflowsignedsubtraction_2x.png","art/overflowunsignedsubtraction_2x.png","art/vectoraddition_2x.png","assign","assignment属性，还需要把运算符的左参数设置成inout","associ","associated)—eith","associativity)的值可取的值有left，right和non","associativity)的值默认为none，优先级(precedence)默认为100","associativity优先级和结合性oper","attribut","avail","a？b：c","b","back","base","basic","be","becom","befor","begin","behav","behavior","behind","below","between","beyond","binari","bit","bit-shift","bitwis","blue","bluecompon","bool","both","bound","boundari","byte","c","c-base","calcul","call","care","cascad","caus","cc","cc6699","certain","charact","characterist","check","class","closer","code","color","combin","combinedbit","combinedvector","commun","compar","complement","complet","complex","compon","compound","condit","consid","constant","context","convert","correspond","count","creat","creation","css","custom","c语言中的数值计算，swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加&+。所有允许溢出的运算符都是以&","data","decim","declar","decod","decompos","default","defin","definit","demonstr","depend","describ","determin","devic","diagram","differ","directli","discard","divid","divis","doesn’t","done","don’t","doubl","driver","dure","each","earlier","easi","effect","eight","eight-bit","empti","enabl","encod","end","ensur","enumer","equal","equival","error","essenc","evalu","even","exact","exactli","exampl","except","exclus","exist","expect","explan","express","extend","extern","extra","factor","familiar","fill","final","first","firstbit","firstbits和otherbits都有一个1跟另一个数不同的。所以按位异或的结果是把它这些位置为1，其他都置为0","firstsixbit","firstsixbits和lastsixbits中间4个位都为1。对它俩进行按位与运算后，就得到了00111100，即十进制的60","firstvector","fit","five","flexibl","follow","form","found","four","freedom","func","function","functions运算符函数prefix","give","given","global","grai","graphic","green","greencompon","group","gt","gt;>","gt;！&","guess","halv","handl","happen","here","here’","hexadecim","higher","higher-preced","hold","ignor","illustr","immedi","implement","implicit","import","includ","increment","indic","individu","infix","initi","initialbit","initialbits操作，然后赋值给invertedbits这个新常量。这个新常量的值等于所有位都取反的initialbits，即1变成0，0变成1，变成了11110000，十进制值为240","inout","input","insert","insid","instanc","instead","int16","int16.max","int16整型能承载的整数范围是-32768到32767","int8","int8.min","integ","integers无符整型的移位操作shift","integers有符整型的移位操作overflow","integer’","intend","interact","invalid","invers","invert","invertedbit","itself","keep","keyword","known","languag","larg","largest","lastsixbit","leav","left","left-associ","left.i","left.x","left和right，代表+左边和右边的两个vector2d对象。函数返回了一个新的vector2d的对象，这个对象的x和y分别等于两个参数对象的x和i","left，优先级为140","let","level","limit","list","locat","logic","look","low-level","lower-preced","lt","lt;<","lt;<和右移运算符>>","make","manipul","mark","mask","match","maximum","mean","method","middl","middlefourbit","minu","modifi","more","morebit","move","much","multipl","multipli","n","name","name=\"bitwise_operators\">$0、$1、$2`。例如，class`class`。反引号不属于标识符的一部分，`x`(x","comparable等同于t","comparable表示任何用于替代类型形参t的类型实参必须满足compar","comparable，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，<t","conformance-requir","constrain","dictionary泛型实参语句泛型形参语句泛型形参语句where语句":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}},"<":{"docs":{},"/":{"docs":{},"p":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.05486968449931413}}}}}},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"表":{"docs":{},"示":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"类":{"docs":{},"c":{"docs":{},"且":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"协":{"docs":{},"议":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"q":{"docs":{},"群":{"docs":{},"：":{"3":{"6":{"4":{"2":{"7":{"9":{"5":{"8":{"8":{"docs":{"index.html#gitbook_101":{"ref":"index.html#gitbook_101","tf":0.06666666666666667}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"u":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}},";":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},";":{"docs":{},")":{"docs":{},"，":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"4":{"2":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"海":{"docs":{},"贼":{"docs":{},"王":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}},"":{"docs":{},"":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"?":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"k":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"之":{"docs":{},"所":{"docs":{},"以":{"docs":{},"叫":{"docs":{},"这":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"人":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"当":{"docs":{},"做":{"docs":{},"输":{"docs":{},"入":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"这":{"docs":{},"个":{"docs":{},"人":{"docs":{},"的":{"docs":{},"问":{"docs":{},"候":{"docs":{},"语":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"完":{"docs":{},"成":{"docs":{},"这":{"docs":{},"个":{"docs":{},"任":{"docs":{},"务":{"docs":{},"，":{"docs":{},"你":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"-":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"，":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"给":{"docs":{},"这":{"docs":{},"个":{"docs":{},"人":{"docs":{},"问":{"docs":{},"候":{"docs":{},"语":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"大":{"docs":{},"于":{"docs":{},"字":{"docs":{},"母":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"大":{"docs":{},"于":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"将":{"docs":{},"会":{"docs":{},"排":{"docs":{},"在":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}},"大":{"docs":{},"于":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}},"按":{"docs":{},"照":{"docs":{},"字":{"docs":{},"母":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"较":{"docs":{},"晚":{"docs":{},"出":{"docs":{},"现":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}},"位":{"docs":{},"左":{"docs":{},"移":{"docs":{},"/":{"docs":{},"右":{"docs":{},"移":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}},"求":{"docs":{},"余":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"比":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"取":{"docs":{},"模":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}},"短":{"docs":{},"路":{"docs":{},"计":{"docs":{},"算":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}},";":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"左":{"docs":{},"端":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"二":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"右":{"docs":{},"边":{"docs":{},"参":{"docs":{},"数":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}},"后":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"子":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"只":{"docs":{},"有":{"docs":{},"最":{"docs":{},"外":{"docs":{},"层":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"才":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"左":{"docs":{},"边":{"docs":{},"参":{"docs":{},"数":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}},"、":{"docs":{},"\\":{"docs":{},"­":{"docs":{},"、":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"未":{"docs":{},"转":{"docs":{},"义":{"docs":{},"的":{"docs":{},"反":{"docs":{},"斜":{"docs":{},"线":{"docs":{},"\\":{"docs":{},"、":{"docs":{},"回":{"docs":{},"车":{"docs":{},"符":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}}}}}}}}}},"）":{"docs":{},"\\":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}},"docs":{}},"docs":{}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}}},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.013651877133105802}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"g":{"docs":{},"h":{"docs":{},"i":{"docs":{},"j":{"docs":{},"k":{"docs":{},"l":{"docs":{},"m":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"index.html#gitbook_101":{"ref":"index.html#gitbook_101","tf":0.06666666666666667},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.023255813953488372},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}},"导":{"docs":{},"演":{"docs":{},"的":{"docs":{},"电":{"docs":{},"影":{"docs":{},"“":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"<":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},">":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},":":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}}},"docs":{}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.260169654906497},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.017766497461928935}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"或":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{},"通":{"docs":{},"过":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"所":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"类":{"docs":{},"或":{"docs":{},"者":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"其":{"docs":{},"属":{"docs":{},"均":{"docs":{},"会":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"。":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"显":{"docs":{},"示":{"docs":{},"器":{"docs":{},"的":{"docs":{},"像":{"docs":{},"素":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"的":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"捆":{"docs":{},"绑":{"docs":{},"和":{"docs":{},"储":{"docs":{},"存":{"docs":{},"在":{"docs":{},"类":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"中":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"当":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"整":{"docs":{},"数":{"0":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"会":{"docs":{},"被":{"docs":{},"推":{"docs":{},"断":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"仅":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"或":{"docs":{},"者":{"docs":{},"视":{"docs":{},"频":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"6":{"4":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"将":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"重":{"docs":{},"置":{"docs":{},"为":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"docs":{}}}}}}}}},"r":{"docs":{},"v":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.04304635761589404}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"中":{"docs":{},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}},"具":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"1":{"docs":{},"。":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"具":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"值":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"计":{"docs":{},"算":{"docs":{},"而":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"是":{"docs":{},"由":{"docs":{},"返":{"docs":{},"回":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"叫":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"（":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"？":{"docs":{},"）":{"docs":{},"。":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"给":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"，":{"docs":{},"且":{"docs":{},"在":{"docs":{},"他":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"通":{"docs":{},"过":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"在":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"引":{"docs":{},"发":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"时":{"docs":{},"没":{"docs":{},"有":{"docs":{},"可":{"docs":{},"以":{"docs":{},"供":{"docs":{},"解":{"docs":{},"析":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"打":{"docs":{},"印":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"房":{"docs":{},"间":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"现":{"docs":{},"在":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.03525264394829612},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.016597510373443983},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.9794589997710398},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4712994626282364},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.02197802197802198},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00808080808080808},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.032520325203252036},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.040229885057471264},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.013784461152882205},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.026905829596412557},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005875440658049354},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.017543859649122806},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.1282051282051282},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"f":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}},"）":{"docs":{},"\\":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"或":{"docs":{},"换":{"docs":{},"行":{"docs":{},"符":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"docs":{}},"docs":{}},"docs":{}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"时":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"将":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"从":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"（":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"后":{"docs":{},"面":{"docs":{},"带":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"写":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"这":{"docs":{},"个":{"docs":{},"关":{"docs":{},"键":{"docs":{},"词":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.03642384105960265}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"1":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.012121212121212121}}},"2":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.006060606060606061}}},"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00808080808080808}}},"docs":{},")":{"docs":{},"和":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"避":{"docs":{},"免":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"获":{"docs":{},"取":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"在":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"移":{"docs":{},"除":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"会":{"docs":{},"移":{"docs":{},"除":{"docs":{},"该":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"并":{"docs":{},"且":{"docs":{},"返":{"docs":{},"回":{"docs":{},"被":{"docs":{},"移":{"docs":{},"除":{"docs":{},"的":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"它":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"的":{"docs":{},"是":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"过":{"docs":{},"程":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"再":{"docs":{},"修":{"docs":{},"改":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"值":{"docs":{},"并":{"docs":{},"不":{"docs":{},"影":{"docs":{},"响":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"所":{"docs":{},"储":{"docs":{},"存":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}}},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.025280898876404494}}}}}},"c":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.011494252873563218}},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"矩":{"docs":{},"形":{"docs":{},"的":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"原":{"docs":{},"点":{"docs":{},"和":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"来":{"docs":{},"算":{"docs":{},"出":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"它":{"docs":{},"以":{"docs":{},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{},"。":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"同":{"docs":{},"时":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"把":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"其":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"正":{"docs":{},"如":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"动":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"级":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"构":{"docs":{},"造":{"docs":{},"新":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}},"方":{"docs":{},"法":{"docs":{},"只":{"docs":{},"是":{"docs":{},"将":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"存":{"docs":{},"储":{"docs":{},"和":{"docs":{},"接":{"docs":{},"收":{"docs":{},"到":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"数":{"docs":{},"目":{"docs":{},"相":{"docs":{},"加":{"docs":{},"，":{"docs":{},"再":{"docs":{},"保":{"docs":{},"存":{"docs":{},"回":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"n":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.04878048780487805}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"(":{"3":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"在":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"中":{"docs":{},"，":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"被":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"能":{"docs":{},"够":{"docs":{},"通":{"docs":{},"过":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"名":{"docs":{},"称":{"docs":{},"单":{"docs":{},"独":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"能":{"docs":{},"正":{"docs":{},"确":{"docs":{},"得":{"docs":{},"输":{"docs":{},"出":{"docs":{},"对":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"牌":{"docs":{},"有":{"1":{"docs":{},"和":{"1":{"1":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"内":{"docs":{},"部":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"其":{"docs":{},"余":{"docs":{},"牌":{"docs":{},"都":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"去":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{},",":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"数":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"的":{"docs":{},"牌":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"从":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"~":{"1":{"0":{"docs":{},",":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{},",":{"1":{"3":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"表":{"docs":{},"示":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},"。":{"docs":{},"(":{"docs":{},"这":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"队":{"docs":{},"列":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"集":{"docs":{},"合":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"，":{"docs":{},"系":{"docs":{},"列":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"特":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"成":{"docs":{},"了":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"）":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.011278195488721804}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"要":{"docs":{},"求":{"docs":{},"其":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"者":{"docs":{},"必":{"docs":{},"须":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}}}}}},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0728476821192053}},"(":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.023178807947019868}}}}}}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"类":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"设":{"docs":{},"定":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.013784461152882205}},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"模":{"docs":{},"拟":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},".":{"docs":{},"它":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"[":{"0":{"docs":{},"-":{"1":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"w":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.04945054945054945}},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"下":{"docs":{},"标":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"来":{"docs":{},"构":{"docs":{},"造":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.020942408376963352}},"定":{"docs":{},"义":{"docs":{},"成":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"无":{"docs":{},"需":{"docs":{},"在":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"管":{"docs":{},"理":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"再":{"docs":{},"被":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.014044943820224719}},"a":{"docs":{},"l":{"docs":{},"增":{"docs":{},"加":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"了":{"docs":{},"当":{"docs":{},"前":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"复":{"docs":{},"制":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"。":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"保":{"docs":{},"证":{"docs":{},"了":{"docs":{},"当":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"候":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"消":{"docs":{},"失":{"docs":{},"，":{"docs":{},"也":{"docs":{},"保":{"docs":{},"证":{"docs":{},"了":{"docs":{},"当":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}}}}}},"l":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}},"c":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.31673966456575153},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}}}},"s":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.033707865168539325}}},"2":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.011251758087201125},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.033707865168539325}},")":{"docs":{},"，":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"在":{"docs":{},"新":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"s":{"1":{"docs":{},"应":{"docs":{},"该":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"2":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"index.html#gitbook_101":{"ref":"index.html#gitbook_101","tf":10.4},"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":10.00587544065805},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":10.404761904761905},"chapter1/chapter1.html#gitbook_106":{"ref":"chapter1/chapter1.html#gitbook_106","tf":10.75},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.06451612903225806},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.02631578947368421},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.04899777282850779},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.008287292817679558},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.033707865168539325},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.020477815699658702},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.030456852791878174},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.013089005235602094},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.009400705052878966},"chapter2/chapter2.html#gitbook_166":{"ref":"chapter2/chapter2.html#gitbook_166","tf":10.666666666666666},"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.08333333333333333},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.006030150753768844},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.019943019943019943}},"中":{"docs":{},"，":{"docs":{},"类":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"和":{"docs":{},"访":{"docs":{},"问":{"docs":{},"超":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"重":{"docs":{},"写":{"docs":{},"（":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"）":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"来":{"docs":{},"优":{"docs":{},"化":{"docs":{},"或":{"docs":{},"修":{"docs":{},"改":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"反":{"docs":{},"方":{"docs":{},"向":{"docs":{},"流":{"docs":{},"动":{"docs":{},"—":{"docs":{},"—":{"docs":{},"从":{"docs":{},"根":{"docs":{},"节":{"docs":{},"点":{"docs":{},"传":{"docs":{},"向":{"docs":{},"叶":{"docs":{},"子":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"常":{"docs":{},"量":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"上":{"docs":{},"的":{"docs":{},"显":{"docs":{},"式":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"注":{"docs":{},"（":{"docs":{},":":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"）":{"docs":{},"导":{"docs":{},"致":{"docs":{},"数":{"docs":{},"字":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"2":{"docs":{},".":{"7":{"1":{"8":{"2":{"8":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"而":{"docs":{},"非":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"常":{"docs":{},"量":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"在":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"左":{"docs":{},"侧":{"docs":{},"）":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"语":{"docs":{},"句":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"在":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"标":{"docs":{},"签":{"docs":{},"）":{"docs":{},"中":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"任":{"docs":{},"何":{"docs":{},"模":{"docs":{},"式":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"标":{"docs":{},"签":{"docs":{},"中":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"其":{"docs":{},"他":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"能":{"docs":{},"够":{"docs":{},"定":{"docs":{},"义":{"docs":{},"方":{"docs":{},"法":{"docs":{},"；":{"docs":{},"事":{"docs":{},"实":{"docs":{},"上":{"docs":{},"这":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"与":{"docs":{},"c":{"docs":{},"/":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"的":{"docs":{},"主":{"docs":{},"要":{"docs":{},"区":{"docs":{},"别":{"docs":{},"之":{"docs":{},"一":{"docs":{},"。":{"docs":{},"在":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},",":{"docs":{},"类":{"docs":{},"是":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"能":{"docs":{},"定":{"docs":{},"义":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"但":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"方":{"docs":{},"法":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"极":{"docs":{},"其":{"docs":{},"相":{"docs":{},"似":{"docs":{},"。":{"docs":{},"像":{"docs":{},"在":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"介":{"docs":{},"词":{"docs":{},"指":{"docs":{},"向":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"：":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{},"b":{"docs":{},"y":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"前":{"docs":{},"面":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"介":{"docs":{},"词":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"让":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"能":{"docs":{},"像":{"docs":{},"一":{"docs":{},"个":{"docs":{},"句":{"docs":{},"子":{"docs":{},"一":{"docs":{},"样":{"docs":{},"被":{"docs":{},"解":{"docs":{},"读":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"命":{"docs":{},"名":{"docs":{},"约":{"docs":{},"定":{"docs":{},"让":{"docs":{},"书":{"docs":{},"写":{"docs":{},"代":{"docs":{},"码":{"docs":{},"更":{"docs":{},"容":{"docs":{},"易":{"docs":{},"了":{"docs":{},",":{"docs":{},"因":{"docs":{},"为":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"下":{"docs":{},"标":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"部":{"docs":{},"分":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"不":{"docs":{},"是":{"docs":{},"每":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"都":{"docs":{},"能":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"值":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"过":{"docs":{},"值":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"；":{"docs":{},"同":{"docs":{},"样":{"docs":{},"想":{"docs":{},"要":{"docs":{},"从":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"某":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"下":{"docs":{},"的":{"docs":{},"值":{"docs":{},"也":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"给":{"docs":{},"这":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"有":{"docs":{},"两":{"docs":{},"类":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"以":{"docs":{},"及":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"当":{"docs":{},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"或":{"docs":{},"便":{"docs":{},"利":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"表":{"docs":{},"明":{"docs":{},"它":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"那":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"。":{"docs":{},"再":{"docs":{},"比":{"docs":{},"如":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"这":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"详":{"docs":{},"情":{"docs":{},"参":{"docs":{},"见":{"docs":{},"类":{"docs":{},"型":{"docs":{},"安":{"docs":{},"全":{"docs":{},"和":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"(":{"docs":{},"待":{"docs":{},"添":{"docs":{},"加":{"docs":{},"链":{"docs":{},"接":{"docs":{},")":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"给":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"插":{"docs":{},"值":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"类":{"docs":{},"似":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"流":{"docs":{},"程":{"docs":{},"控":{"docs":{},"制":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"可":{"docs":{},"以":{"docs":{},"多":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"任":{"docs":{},"务":{"docs":{},"的":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"和":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"，":{"docs":{},"基":{"docs":{},"于":{"docs":{},"特":{"docs":{},"定":{"docs":{},"条":{"docs":{},"件":{"docs":{},"选":{"docs":{},"择":{"docs":{},"执":{"docs":{},"行":{"docs":{},"不":{"docs":{},"同":{"docs":{},"代":{"docs":{},"码":{"docs":{},"分":{"docs":{},"支":{"docs":{},"的":{"docs":{},"i":{"docs":{},"f":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"程":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"其":{"docs":{},"他":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"种":{"docs":{},"优":{"docs":{},"雅":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"解":{"docs":{},"决":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"题":{"docs":{},"，":{"docs":{},"称":{"docs":{},"之":{"docs":{},"为":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"占":{"docs":{},"用":{"docs":{},"列":{"docs":{},"表":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"两":{"docs":{},"种":{"docs":{},"办":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"解":{"docs":{},"决":{"docs":{},"你":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"所":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"问":{"docs":{},"题":{"docs":{},"：":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"(":{"docs":{},"w":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"不":{"docs":{},"会":{"docs":{},"从":{"docs":{},"上":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"落":{"docs":{},"入":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"整":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"它":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"相":{"docs":{},"比":{"docs":{},"之":{"docs":{},"下":{"docs":{},"，":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"要":{"docs":{},"求":{"docs":{},"你":{"docs":{},"显":{"docs":{},"示":{"docs":{},"的":{"docs":{},"插":{"docs":{},"入":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"到":{"docs":{},"每":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"的":{"docs":{},"末":{"docs":{},"尾":{"docs":{},"来":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"自":{"docs":{},"动":{"docs":{},"落":{"docs":{},"入":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"这":{"docs":{},"种":{"docs":{},"避":{"docs":{},"免":{"docs":{},"默":{"docs":{},"认":{"docs":{},"落":{"docs":{},"入":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"它":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"来":{"docs":{},"创":{"docs":{},"造":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"两":{"docs":{},"者":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"来":{"docs":{},"提":{"docs":{},"前":{"docs":{},"结":{"docs":{},"束":{"docs":{},"整":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"体":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"显":{"docs":{},"示":{"docs":{},"地":{"docs":{},"指":{"docs":{},"明":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"想":{"docs":{},"要":{"docs":{},"终":{"docs":{},"止":{"docs":{},"的":{"docs":{},"是":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},",":{"docs":{},"会":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"类":{"docs":{},"似":{"docs":{},"地":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"有":{"docs":{},"许":{"docs":{},"多":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"，":{"docs":{},"显":{"docs":{},"示":{"docs":{},"指":{"docs":{},"明":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"需":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"分":{"docs":{},"支":{"docs":{},"而":{"docs":{},"且":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"有":{"docs":{},"为":{"docs":{},"空":{"docs":{},"的":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"有":{"docs":{},"时":{"docs":{},"为":{"docs":{},"了":{"docs":{},"使":{"docs":{},"你":{"docs":{},"的":{"docs":{},"意":{"docs":{},"图":{"docs":{},"更":{"docs":{},"明":{"docs":{},"显":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"特":{"docs":{},"意":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"或":{"docs":{},"者":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"某":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"当":{"docs":{},"你":{"docs":{},"想":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"某":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"该":{"docs":{},"分":{"docs":{},"支":{"docs":{},"内":{"docs":{},"写":{"docs":{},"上":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"当":{"docs":{},"那":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"时":{"docs":{},"，":{"docs":{},"分":{"docs":{},"支":{"docs":{},"内":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"立":{"docs":{},"即":{"docs":{},"结":{"docs":{},"束":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"相":{"docs":{},"对":{"docs":{},"小":{"docs":{},"点":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"由":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"几":{"docs":{},"乎":{"docs":{},"无":{"docs":{},"处":{"docs":{},"不":{"docs":{},"在":{"docs":{},"的":{"docs":{},"许":{"docs":{},"多":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"以":{"docs":{},"及":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"都":{"docs":{},"由":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"和":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"紧":{"docs":{},"接":{"docs":{},"中":{"docs":{},"括":{"docs":{},"号":{"docs":{},"[":{"docs":{},"]":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"复":{"docs":{},"合":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"指":{"docs":{},"定":{"docs":{},"义":{"docs":{},"时":{"docs":{},"可":{"docs":{},"以":{"docs":{},"给":{"docs":{},"定":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"包":{"docs":{},"括":{"docs":{},"类":{"docs":{},"、":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"、":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"和":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"类":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"用":{"docs":{},"户":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"!":{"docs":{},"作":{"docs":{},"为":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"命":{"docs":{},"名":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"y":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"身":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"描":{"docs":{},"述":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}},"统":{"docs":{},"一":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"语":{"docs":{},"法":{"docs":{},"足":{"docs":{},"够":{"docs":{},"灵":{"docs":{},"活":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"从":{"docs":{},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"没":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"c":{"docs":{},"风":{"docs":{},"格":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"到":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"带":{"docs":{},"局":{"docs":{},"部":{"docs":{},"和":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"的":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"仅":{"docs":{},"给":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"一":{"docs":{},"个":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},";":{"docs":{},"但":{"docs":{},"是":{"docs":{},"默":{"docs":{},"认":{"docs":{},"同":{"docs":{},"时":{"docs":{},"给":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"和":{"docs":{},"后":{"docs":{},"续":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"和":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"约":{"docs":{},"定":{"docs":{},"与":{"docs":{},"典":{"docs":{},"型":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"和":{"docs":{},"调":{"docs":{},"用":{"docs":{},"约":{"docs":{},"定":{"docs":{},"相":{"docs":{},"适":{"docs":{},"应":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"你":{"docs":{},"在":{"docs":{},"写":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"链":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"为":{"docs":{},"空":{"docs":{},"有":{"docs":{},"些":{"docs":{},"相":{"docs":{},"像":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"测":{"docs":{},"器":{"docs":{},"能":{"docs":{},"够":{"docs":{},"演":{"docs":{},"绎":{"docs":{},"出":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}},"内":{"docs":{},"建":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"5":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}},"docs":{}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"已":{"docs":{},"经":{"docs":{},"提":{"docs":{},"供":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"通":{"docs":{},"过":{"docs":{},"下":{"docs":{},"标":{"docs":{},"来":{"docs":{},"查":{"docs":{},"找":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"都":{"docs":{},"达":{"docs":{},"到":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"去":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"简":{"docs":{},"单":{"docs":{},"声":{"docs":{},"明":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"而":{"docs":{},"已":{"docs":{},"。":{"docs":{},"如":{"docs":{},"何":{"docs":{},"实":{"docs":{},"践":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"在":{"docs":{},"[":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"对":{"docs":{},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"其":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"做":{"docs":{},"了":{"docs":{},"些":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"在":{"docs":{},"[":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{},"[":{"5":{"docs":{},"]":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"中":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"其":{"docs":{},"是":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"之":{"docs":{},"所":{"docs":{},"以":{"docs":{},"需":{"docs":{},"要":{"docs":{},"其":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},"是":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"为":{"docs":{},"了":{"docs":{},"以":{"docs":{},"便":{"docs":{},"于":{"docs":{},"其":{"docs":{},"检":{"docs":{},"查":{"docs":{},"其":{"docs":{},"是":{"docs":{},"否":{"docs":{},"包":{"docs":{},"含":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"无":{"docs":{},"此":{"docs":{},"需":{"docs":{},"求":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"即":{"docs":{},"不":{"docs":{},"会":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"是":{"docs":{},"否":{"docs":{},"插":{"docs":{},"入":{"docs":{},"或":{"docs":{},"者":{"docs":{},"替":{"docs":{},"换":{"docs":{},"了":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"查":{"docs":{},"找":{"docs":{},"到":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"字":{"docs":{},"典":{"docs":{},"里":{"docs":{},"面":{"docs":{},"的":{"docs":{},"给":{"docs":{},"定":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"较":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"来":{"docs":{},"得":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"和":{"docs":{},"保":{"docs":{},"守":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"跟":{"docs":{},"基":{"docs":{},"于":{"docs":{},"c":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"在":{"docs":{},"移":{"docs":{},"植":{"docs":{},"已":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"到":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"基":{"docs":{},"于":{"docs":{},"c":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}},"大":{"docs":{},"部":{"docs":{},"分":{"docs":{},"标":{"docs":{},"准":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"且":{"docs":{},"改":{"docs":{},"进":{"docs":{},"许":{"docs":{},"多":{"docs":{},"特":{"docs":{},"性":{"docs":{},"来":{"docs":{},"减":{"docs":{},"少":{"docs":{},"常":{"docs":{},"规":{"docs":{},"编":{"docs":{},"码":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"如":{"docs":{},"，":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"符":{"docs":{},"=":{"docs":{},"不":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"以":{"docs":{},"防":{"docs":{},"止":{"docs":{},"错":{"docs":{},"把":{"docs":{},"等":{"docs":{},"号":{"docs":{},"=":{"docs":{},"=":{"docs":{},"写":{"docs":{},"成":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"号":{"docs":{},"=":{"docs":{},"而":{"docs":{},"导":{"docs":{},"致":{"docs":{},"b":{"docs":{},"u":{"docs":{},"g":{"docs":{},"。":{"docs":{},"数":{"docs":{},"值":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"(":{"docs":{},"+":{"docs":{},"，":{"docs":{},"-":{"docs":{},"，":{"docs":{},"*":{"docs":{},"，":{"docs":{},"/":{"docs":{},"，":{"docs":{},"%":{"docs":{},"等":{"docs":{},")":{"docs":{},"会":{"docs":{},"检":{"docs":{},"测":{"docs":{},"并":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"值":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"来":{"docs":{},"避":{"docs":{},"免":{"docs":{},"保":{"docs":{},"存":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"由":{"docs":{},"于":{"docs":{},"变":{"docs":{},"量":{"docs":{},"大":{"docs":{},"于":{"docs":{},"或":{"docs":{},"小":{"docs":{},"于":{"docs":{},"其":{"docs":{},"类":{"docs":{},"型":{"docs":{},"所":{"docs":{},"能":{"docs":{},"承":{"docs":{},"载":{"docs":{},"的":{"docs":{},"范":{"docs":{},"围":{"docs":{},"时":{"docs":{},"导":{"docs":{},"致":{"docs":{},"的":{"docs":{},"异":{"docs":{},"常":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"当":{"docs":{},"然":{"docs":{},"允":{"docs":{},"许":{"docs":{},"你":{"docs":{},"选":{"docs":{},"择":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"有":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"释":{"docs":{},"放":{"docs":{},"不":{"docs":{},"再":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"以":{"docs":{},"释":{"docs":{},"放":{"docs":{},"资":{"docs":{},"源":{"docs":{},"。":{"docs":{},"如":{"docs":{},"自":{"docs":{},"动":{"docs":{},"引":{"docs":{},"用":{"docs":{},"计":{"docs":{},"数":{"docs":{},"那":{"docs":{},"一":{"docs":{},"章":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"通":{"docs":{},"过":{"docs":{},"自":{"docs":{},"动":{"docs":{},"引":{"docs":{},"用":{"docs":{},"计":{"docs":{},"数":{"docs":{},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"自":{"docs":{},"动":{"docs":{},"引":{"docs":{},"用":{"docs":{},"计":{"docs":{},"数":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},")":{"docs":{},"这":{"docs":{},"一":{"docs":{},"机":{"docs":{},"制":{"docs":{},"来":{"docs":{},"跟":{"docs":{},"踪":{"docs":{},"和":{"docs":{},"管":{"docs":{},"理":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"管":{"docs":{},"理":{"docs":{},"机":{"docs":{},"制":{"docs":{},"会":{"docs":{},"一":{"docs":{},"直":{"docs":{},"起":{"docs":{},"着":{"docs":{},"作":{"docs":{},"用":{"docs":{},"，":{"docs":{},"你":{"docs":{},"无":{"docs":{},"须":{"docs":{},"自":{"docs":{},"己":{"docs":{},"来":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"内":{"docs":{},"存":{"docs":{},"的":{"docs":{},"管":{"docs":{},"理":{"docs":{},"。":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"如":{"docs":{},"下":{"docs":{},"要":{"docs":{},"求":{"docs":{},"：":{"docs":{},"只":{"docs":{},"要":{"docs":{},"在":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"内":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"（":{"docs":{},"而":{"docs":{},"不":{"docs":{},"只":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"或":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"提":{"docs":{},"醒":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"就":{"docs":{},"占":{"docs":{},"有":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"链":{"docs":{},"接":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"？":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"存":{"docs":{},"在":{"docs":{},"则":{"docs":{},"取":{"docs":{},"回":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"’":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}},"内":{"docs":{},"建":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"下":{"docs":{},"标":{"docs":{},"。":{"docs":{},"该":{"docs":{},"下":{"docs":{},"标":{"docs":{},"[":{"docs":{},"n":{"docs":{},"]":{"docs":{},"返":{"docs":{},"回":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"数":{"docs":{},"字":{"docs":{},"从":{"docs":{},"右":{"docs":{},"向":{"docs":{},"左":{"docs":{},"数":{"docs":{},"的":{"docs":{},"第":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"你":{"docs":{},"定":{"docs":{},"义":{"docs":{},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"、":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"如":{"docs":{},"同":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"，":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"写":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"你":{"docs":{},"或":{"docs":{},"许":{"docs":{},"会":{"docs":{},"定":{"docs":{},"义":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"为":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"和":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"要":{"docs":{},"求":{"docs":{},"任":{"docs":{},"何":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"现":{"docs":{},"等":{"docs":{},"式":{"docs":{},"符":{"docs":{},"(":{"docs":{},"=":{"docs":{},"=":{"docs":{},")":{"docs":{},"和":{"docs":{},"不":{"docs":{},"等":{"docs":{},"符":{"docs":{},"(":{"docs":{},"!":{"docs":{},"=":{"docs":{},")":{"docs":{},"对":{"docs":{},"任":{"docs":{},"何":{"docs":{},"两":{"docs":{},"个":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"类":{"docs":{},"型":{"docs":{},"自":{"docs":{},"动":{"docs":{},"支":{"docs":{},"持":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"见":{"docs":{},"章":{"docs":{},"节":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"与":{"docs":{},"输":{"docs":{},"入":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"则":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"使":{"docs":{},"用":{"docs":{},"=":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"来":{"docs":{},"比":{"docs":{},"较":{"docs":{},"两":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"它":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"与":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"考":{"docs":{},"，":{"docs":{},"你":{"docs":{},"不":{"docs":{},"用":{"docs":{},"在":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"定":{"docs":{},"义":{"docs":{},"部":{"docs":{},"分":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"强":{"docs":{},"大":{"docs":{},"特":{"docs":{},"征":{"docs":{},"中":{"docs":{},"的":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"，":{"docs":{},"许":{"docs":{},"多":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"代":{"docs":{},"码":{"docs":{},"构":{"docs":{},"建":{"docs":{},"出":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"事":{"docs":{},"实":{"docs":{},"上":{"docs":{},"，":{"docs":{},"你":{"docs":{},"已":{"docs":{},"经":{"docs":{},"使":{"docs":{},"用":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"贯":{"docs":{},"穿":{"docs":{},"着":{"docs":{},"整":{"docs":{},"个":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"。":{"docs":{},"此":{"docs":{},"处":{"docs":{},"为":{"docs":{},"了":{"docs":{},"演":{"docs":{},"示":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"让":{"docs":{},"+":{"docs":{},"+":{"docs":{},"+":{"docs":{},"对":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"有":{"docs":{},"许":{"docs":{},"多":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"高":{"docs":{},"级":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"了":{"docs":{},"c":{"docs":{},"语":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"?":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"广":{"docs":{},"泛":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"允":{"docs":{},"许":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"很":{"docs":{},"多":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"或":{"docs":{},"部":{"docs":{},"分":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"本":{"docs":{},"身":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"存":{"docs":{},"在":{"docs":{},"两":{"docs":{},"种":{"docs":{},"复":{"docs":{},"合":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"：":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"复":{"docs":{},"合":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"其":{"docs":{},"它":{"docs":{},"复":{"docs":{},"合":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.014732965009208104},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.027303754266211604},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.006324110671936759},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":2.242165242165242},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"中":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"子":{"docs":{},"句":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"会":{"docs":{},"退":{"docs":{},"出":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"向":{"docs":{},"下":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"每":{"docs":{},"个":{"docs":{},"子":{"docs":{},"句":{"docs":{},"结":{"docs":{},"尾":{"docs":{},"写":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"中":{"docs":{},"断":{"docs":{},"该":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"表":{"docs":{},"示":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"后":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"打":{"docs":{},"印":{"docs":{},"该":{"docs":{},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"数":{"docs":{},"字":{"5":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"是":{"docs":{},"否":{"docs":{},"曾":{"docs":{},"经":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"过":{"docs":{},"值":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"缘":{"docs":{},"故":{"docs":{},"，":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"曾":{"docs":{},"被":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"或":{"docs":{},"者":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"支":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"包":{"docs":{},"含":{"docs":{},"注":{"docs":{},"释":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"被":{"docs":{},"报":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"注":{"docs":{},"释":{"docs":{},"不":{"docs":{},"是":{"docs":{},"代":{"docs":{},"码":{"docs":{},"语":{"docs":{},"句":{"docs":{},"而":{"docs":{},"且":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"让":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"达":{"docs":{},"到":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"的":{"docs":{},"效":{"docs":{},"果":{"docs":{},"。":{"docs":{},"你":{"docs":{},"总":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"不":{"docs":{},"会":{"docs":{},"同":{"docs":{},"时":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"引":{"docs":{},"起":{"docs":{},"编":{"docs":{},"译":{"docs":{},"期":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"—":{"docs":{},"—":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"测":{"docs":{},"试":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"元":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"值":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"范":{"docs":{},"围":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"划":{"docs":{},"线":{"docs":{},"(":{"docs":{},"_":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843}}}}},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"和":{"docs":{},"书":{"docs":{},"写":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"当":{"docs":{},"多":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"含":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"值":{"docs":{},"且":{"docs":{},"能":{"docs":{},"够":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"只":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"值":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"与":{"docs":{},"之":{"docs":{},"对":{"docs":{},"应":{"docs":{},"。":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"判":{"docs":{},"断":{"docs":{},"某":{"docs":{},"个":{"docs":{},"点":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"红":{"docs":{},"色":{"docs":{},"的":{"docs":{},"x":{"docs":{},"轴":{"docs":{},"上":{"docs":{},"，":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"黄":{"docs":{},"色":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}},"绿":{"docs":{},"色":{"docs":{},"的":{"docs":{},"对":{"docs":{},"角":{"docs":{},"线":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}},"是":{"docs":{},"原":{"docs":{},"点":{"docs":{},"(":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}}}}}}}}}}}},"尝":{"docs":{},"试":{"docs":{},"把":{"docs":{},"某":{"docs":{},"个":{"docs":{},"值":{"docs":{},"与":{"docs":{},"若":{"docs":{},"干":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"。":{"docs":{},"根":{"docs":{},"据":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"当":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"较":{"docs":{},"多":{"docs":{},"时":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"替":{"docs":{},"换":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"完":{"docs":{},"备":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"值":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"与":{"docs":{},"之":{"docs":{},"对":{"docs":{},"应":{"docs":{},"。":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"涵":{"docs":{},"盖":{"docs":{},"所":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},")":{"docs":{},"块":{"docs":{},"满":{"docs":{},"足":{"docs":{},"该":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"全":{"docs":{},"面":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"了":{"docs":{},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"那":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"将":{"docs":{},"无":{"docs":{},"法":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"译":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"没":{"docs":{},"有":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"到":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"值":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"案":{"docs":{},"例":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}},"检":{"docs":{},"查":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"这":{"docs":{},"次":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"提":{"docs":{},"取":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"提":{"docs":{},"取":{"docs":{},"每":{"docs":{},"个":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"）":{"docs":{},"或":{"docs":{},"者":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"由":{"docs":{},"多":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"构":{"docs":{},"成":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"某":{"docs":{},"些":{"docs":{},"更":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"强":{"docs":{},"制":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"(":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"默":{"docs":{},"认":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},")":{"docs":{},"块":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"都":{"docs":{},"无":{"docs":{},"法":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"只":{"docs":{},"能":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"，":{"docs":{},"它":{"docs":{},"由":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"和":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"其":{"docs":{},"后":{"docs":{},"的":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"(":{"docs":{},":":{"docs":{},")":{"docs":{},"组":{"docs":{},"成":{"docs":{},"。":{"docs":{},"在":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"可":{"docs":{},"以":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"语":{"docs":{},"句":{"docs":{},"或":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"更":{"docs":{},"改":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"，":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"指":{"docs":{},"定":{"docs":{},"标":{"docs":{},"签":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"这":{"docs":{},"两":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"用":{"docs":{},"法":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.017094017094017096},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235}},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}},"s":{"docs":{},"(":{"docs":{},"&":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}},"函":{"docs":{},"数":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"交":{"docs":{},"换":{"docs":{},"a":{"docs":{},"与":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"先":{"docs":{},"将":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"存":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"暂":{"docs":{},"时":{"docs":{},"常":{"docs":{},"量":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"a":{"docs":{},"中":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"a":{"docs":{},"，":{"docs":{},"最":{"docs":{},"后":{"docs":{},"将":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"a":{"docs":{},"幅":{"docs":{},"值":{"docs":{},"给":{"docs":{},"b":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"任":{"docs":{},"何":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"修":{"docs":{},"改":{"docs":{},"了":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"分":{"docs":{},"别":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"交":{"docs":{},"换":{"docs":{},"b":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"到":{"docs":{},"a":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"交":{"docs":{},"换":{"docs":{},"a":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"到":{"docs":{},"b":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"它":{"docs":{},"只":{"docs":{},"能":{"docs":{},"交":{"docs":{},"换":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"或":{"docs":{},"者":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{},"用":{"docs":{},"来":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}},"函":{"docs":{},"数":{"docs":{},"主":{"docs":{},"题":{"docs":{},"都":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"，":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"不":{"docs":{},"同":{"docs":{},"之":{"docs":{},"处":{"docs":{},"就":{"docs":{},"在":{"docs":{},"于":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"&":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}},"<":{"docs":{},"t":{"docs":{},">":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"。":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"并":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"名":{"docs":{},"后":{"docs":{},"面":{"docs":{},"，":{"docs":{},"并":{"docs":{},"用":{"docs":{},"一":{"docs":{},"对":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"（":{"docs":{},"如":{"docs":{},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"）":{"docs":{},"，":{"docs":{},"或":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"或":{"docs":{},"用":{"docs":{},"作":{"docs":{},"函":{"docs":{},"数":{"docs":{},"主":{"docs":{},"体":{"docs":{},"中":{"docs":{},"的":{"docs":{},"注":{"docs":{},"释":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"被":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"所":{"docs":{},"代":{"docs":{},"表":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"管":{"docs":{},"函":{"docs":{},"数":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"候":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"所":{"docs":{},"替":{"docs":{},"换":{"docs":{},"（":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"当":{"docs":{},"函":{"docs":{},"数":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"t":{"docs":{},"被":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"替":{"docs":{},"换":{"docs":{},"，":{"docs":{},"第":{"docs":{},"二":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"被":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"主":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"，":{"docs":{},"只":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"行":{"docs":{},"稍":{"docs":{},"微":{"docs":{},"有":{"docs":{},"那":{"docs":{},"么":{"docs":{},"一":{"docs":{},"点":{"docs":{},"点":{"docs":{},"不":{"docs":{},"同":{"docs":{},"于":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"除":{"docs":{},"了":{"docs":{},"只":{"docs":{},"要":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"外":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"每":{"docs":{},"次":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"或":{"docs":{},"一":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"单":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"集":{"docs":{},"，":{"docs":{},"如":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"）":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"一":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"母":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"为":{"docs":{},"整":{"docs":{},"型":{"docs":{},"计":{"docs":{},"算":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"5":{"docs":{},"个":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"docs":{}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.015228426395939087},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.006658832745789268}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}},"y":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"v":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"依":{"docs":{},"然":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"值":{"docs":{},"。":{"docs":{},"没":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"叫":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"。":{"docs":{},"它":{"docs":{},"其":{"docs":{},"实":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"展":{"docs":{},"示":{"docs":{},"的":{"docs":{},"是":{"docs":{},"用":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"中":{"docs":{},"传":{"docs":{},"给":{"docs":{},"它":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"参":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"叫":{"docs":{},"w":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{},"e":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"直":{"docs":{},"接":{"docs":{},"输":{"docs":{},"出":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"先":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"名":{"docs":{},"为":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"了":{"docs":{},"给":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"问":{"docs":{},"候":{"docs":{},"消":{"docs":{},"息":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"用":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"问":{"docs":{},"候":{"docs":{},"返":{"docs":{},"回":{"docs":{},"出":{"docs":{},"去":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"t":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}}}},"p":{"docs":{},"e":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}},"t":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2620493541546173},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}},"r":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.02631578947368421},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.056910569105691054},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}}}},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"l":{"docs":{},"f":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.8927014641779367},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.010101010101010102},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.02586206896551724},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2977745872218234},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.004801097393689987}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.020202020202020204},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"e":{"docs":{},")":{"docs":{},">":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},"<":{"docs":{},"/":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.006060606060606061}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00808080808080808}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"n":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"区":{"docs":{},"别":{"docs":{},"实":{"docs":{},"例":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"像":{"docs":{},"传":{"docs":{},"入":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"给":{"docs":{},"类":{"docs":{},"传":{"docs":{},"入":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"每":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"—":{"docs":{},"—":{"docs":{},"无":{"docs":{},"论":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"就":{"docs":{},"像":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"还":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"就":{"docs":{},"像":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"不":{"docs":{},"论":{"docs":{},"何":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"知":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"没":{"docs":{},"有":{"docs":{},"明":{"docs":{},"确":{"docs":{},"的":{"docs":{},"写":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"假":{"docs":{},"定":{"docs":{},"你":{"docs":{},"是":{"docs":{},"指":{"docs":{},"当":{"docs":{},"前":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"假":{"docs":{},"定":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"已":{"docs":{},"经":{"docs":{},"示":{"docs":{},"范":{"docs":{},"了":{"docs":{},"：":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"三":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"都":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"全":{"docs":{},"新":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"就":{"docs":{},"认":{"docs":{},"为":{"docs":{},"两":{"docs":{},"次":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"x":{"docs":{},"都":{"docs":{},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"名":{"docs":{},"称":{"docs":{},"为":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}},"消":{"docs":{},"除":{"docs":{},"方":{"docs":{},"法":{"docs":{},"参":{"docs":{},"数":{"docs":{},"x":{"docs":{},"和":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"完":{"docs":{},"全":{"docs":{},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"隐":{"docs":{},"含":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"只":{"docs":{},"占":{"docs":{},"有":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"持":{"docs":{},"有":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"将":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"docs":{},"用":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"来":{"docs":{},"占":{"docs":{},"有":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"产":{"docs":{},"生":{"docs":{},"一":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{},"一":{"docs":{},"种":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"模":{"docs":{},"型":{"docs":{},"表":{"docs":{},"示":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"其":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"标":{"docs":{},"注":{"docs":{},"为":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"适":{"docs":{},"配":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}},"[":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"[":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483}},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"6":{"docs":{},":":{"0":{"0":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.009398496240601503},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005483744614179397},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":5.011278195488722},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"你":{"docs":{},"也":{"docs":{},"一":{"docs":{},"定":{"docs":{},"要":{"docs":{},"提":{"docs":{},"供":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"不":{"docs":{},"想":{"docs":{},"在":{"docs":{},"重":{"docs":{},"写":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"里":{"docs":{},"修":{"docs":{},"改":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"直":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"正":{"docs":{},"如":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"副":{"docs":{},"本":{"docs":{},"合":{"docs":{},"成":{"docs":{},"，":{"docs":{},"由":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"属":{"docs":{},"性":{"docs":{},"本":{"docs":{},"身":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"需":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.08333333333333333},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.08333333333333333}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},")":{"docs":{},"被":{"docs":{},"为":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"类":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"实":{"docs":{},"现":{"docs":{},".":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"被":{"docs":{},"转":{"docs":{},"移":{"docs":{},"到":{"docs":{},"了":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"n":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.007050528789659225}},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"类":{"docs":{},"缺":{"docs":{},"少":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939}}}}},"o":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.031180400890868598}},"[":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}},"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"4":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"6":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}}}}},"docs":{}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"“":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"“":{"docs":{},"，":{"docs":{},"记":{"docs":{},"作":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"由":{"docs":{},"两":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"（":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"创":{"docs":{},"建":{"docs":{},"）":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"只":{"docs":{},"有":{"5":{"docs":{},"项":{"docs":{},"，":{"docs":{},"不":{"docs":{},"包":{"docs":{},"括":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4375915974596971}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.31478118434640173},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.012925969447708578}}}}}}}},"s":{"docs":{},")":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.01527614571092832}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"e":{"docs":{},"时":{"docs":{},"候":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"用":{"docs":{},"来":{"docs":{},"标":{"docs":{},"记":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"修":{"docs":{},"改":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"1":{"7":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}},"docs":{}},"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"<":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"f":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"l":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}},"x":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}}}},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"z":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.028735632183908046},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}}}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}},"封":{"docs":{},"装":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4375915974596971}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"w":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"g":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.312431008083182},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"0":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}},"中":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"1":{"docs":{},"，":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"2":{"docs":{},"。":{"docs":{},"c":{"1":{"docs":{},"和":{"docs":{},"c":{"2":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"1":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"的":{"docs":{},"重":{"docs":{},"写":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"超":{"docs":{},"类":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"或":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"重":{"docs":{},"写":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"超":{"docs":{},"类":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},">":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198}},".":{"1":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}},"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"x":{"docs":{},"(":{"1":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"(":{"2":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"docs":{}}},"docs":{}}}}}}}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.017064846416382253}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}}}}}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.011695906432748537},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704}}}}}}}}},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"变":{"docs":{},"量":{"docs":{},"通":{"docs":{},"过":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},"等":{"docs":{},"）":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"符":{"docs":{},"合":{"docs":{},"标":{"docs":{},"准":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.012690355329949238}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"这":{"docs":{},"个":{"docs":{},"子":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"以":{"docs":{},"上":{"docs":{},"操":{"docs":{},"作":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"从":{"docs":{},"新":{"docs":{},"设":{"docs":{},"置":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"4":{"2":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"?":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"一":{"docs":{},"样":{"docs":{},",":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"可":{"docs":{},"选":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"称":{"docs":{},"后":{"docs":{},"加":{"docs":{},"上":{"docs":{},"?":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"否":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},".":{"docs":{},"可":{"docs":{},"选":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704}},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}},"：":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.007473841554559043}},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}}}}}}}}},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"[":{"docs":{},"]":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}},"a":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}},"e":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"引":{"docs":{},"用":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}},"都":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"[":{"docs":{},"]":{"docs":{},"获":{"docs":{},"取":{"docs":{},"访":{"docs":{},"问":{"docs":{},"：":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"是":{"docs":{},"指":{"docs":{},"第":{"0":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"“":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"[":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"u":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"s":{"docs":{},"和":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"位":{"docs":{},"上":{"docs":{},"有":{"1":{"docs":{},"。":{"docs":{},"按":{"docs":{},"位":{"docs":{},"或":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"0":{"docs":{},"，":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"2":{"5":{"4":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.011695906432748537},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.46568148510014656}},"(":{"docs":{},"[":{"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.02247191011235955}}}}}},"函":{"docs":{},"数":{"docs":{},"当":{"docs":{},"排":{"docs":{},"序":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"排":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"面":{"docs":{},"还":{"docs":{},"是":{"docs":{},"后":{"docs":{},"面":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"前":{"docs":{},"面":{"docs":{},"，":{"docs":{},"排":{"docs":{},"序":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"函":{"docs":{},"数":{"docs":{},"需":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"反":{"docs":{},"之":{"docs":{},"返":{"docs":{},"回":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"进":{"docs":{},"行":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}},"期":{"docs":{},"望":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}},"r":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"n":{"docs":{},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.02766798418972332}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695}},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"计":{"docs":{},"算":{"docs":{},"数":{"docs":{},"组":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}},"检":{"docs":{},"查":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"末":{"docs":{},"尾":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}}}},"r":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"）":{"docs":{},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"2":{"0":{"docs":{},"）":{"docs":{},"、":{"docs":{},"换":{"docs":{},"行":{"docs":{},"符":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.016597510373443983}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987}},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"会":{"docs":{},"去":{"docs":{},"检":{"docs":{},"查":{"docs":{},"新":{"docs":{},"值":{"docs":{},"与":{"docs":{},"限":{"docs":{},"制":{"docs":{},"值":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"将":{"docs":{},"超":{"docs":{},"类":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"和":{"4":{"0":{"docs":{},".":{"0":{"docs":{},"中":{"docs":{},"较":{"docs":{},"小":{"docs":{},"的":{"docs":{},"那":{"docs":{},"个":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"较":{"docs":{},"小":{"docs":{},"由":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"决":{"docs":{},"定":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"全":{"docs":{},"局":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"大":{"docs":{},"于":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"的":{"docs":{},"数":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"打":{"docs":{},"印":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"，":{"docs":{},"你":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"速":{"docs":{},"度":{"docs":{},"被":{"docs":{},"限":{"docs":{},"制":{"docs":{},"在":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"。":{"docs":{},"类":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"表":{"docs":{},"示":{"docs":{},"安":{"docs":{},"装":{"docs":{},"了":{"docs":{},"限":{"docs":{},"速":{"docs":{},"装":{"docs":{},"置":{"docs":{},"的":{"docs":{},"车":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"最":{"docs":{},"高":{"docs":{},"速":{"docs":{},"度":{"docs":{},"只":{"docs":{},"能":{"docs":{},"达":{"docs":{},"到":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"重":{"docs":{},"写":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"f":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"替":{"docs":{},"换":{"docs":{},"为":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.022099447513812154},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.012531328320802004}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}},"的":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"点":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"，":{"docs":{},"这":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"跟":{"docs":{},"直":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"通":{"docs":{},"过":{"docs":{},"计":{"docs":{},"算":{"docs":{},"然":{"docs":{},"后":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"表":{"docs":{},"示":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"。":{"docs":{},"如":{"docs":{},"代":{"docs":{},"码":{"docs":{},"所":{"docs":{},"示":{"docs":{},"，":{"docs":{},"它":{"docs":{},"正":{"docs":{},"确":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"(":{"5":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"原":{"docs":{},"点":{"docs":{},"是":{"docs":{},"(":{"0":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"两":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{},"类":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"类":{"docs":{},"将":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"实":{"docs":{},"现":{"docs":{},"为":{"docs":{},"可":{"docs":{},"读":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},".":{"docs":{},"它":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"都":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"必":{"docs":{},"备":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.674953959484346},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.1111111111111111},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0102880658436214}},"s":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"就":{"docs":{},"避":{"docs":{},"免":{"docs":{},"了":{"docs":{},"意":{"docs":{},"外":{"docs":{},"地":{"docs":{},"从":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}},"）":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"递":{"docs":{},"增":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"转":{"docs":{},"到":{"docs":{},"第":{"1":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}},"2":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}},"docs":{}}}}}}}},"’":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}},"-":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.025089605734767026}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}}},"i":{"docs":{},"c":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.007712082262210797},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.01775147928994083},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"类":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"来":{"docs":{},"为":{"docs":{},"类":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.007473841554559043}},"(":{"docs":{},"栈":{"docs":{},")":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"栈":{"docs":{},"是":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"值":{"docs":{},"域":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"和":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"数":{"docs":{},"组":{"docs":{},")":{"docs":{},"相":{"docs":{},"似":{"docs":{},"，":{"docs":{},"但":{"docs":{},"其":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"比":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"更":{"docs":{},"多":{"docs":{},"限":{"docs":{},"制":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"可":{"docs":{},"以":{"docs":{},"允":{"docs":{},"许":{"docs":{},"其":{"docs":{},"里":{"docs":{},"面":{"docs":{},"任":{"docs":{},"何":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"插":{"docs":{},"入":{"docs":{},"/":{"docs":{},"删":{"docs":{},"除":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"而":{"docs":{},"栈":{"docs":{},"，":{"docs":{},"只":{"docs":{},"允":{"docs":{},"许":{"docs":{},"，":{"docs":{},"只":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"末":{"docs":{},"端":{"docs":{},"添":{"docs":{},"加":{"docs":{},"新":{"docs":{},"的":{"docs":{},"项":{"docs":{},"（":{"docs":{},"如":{"docs":{},"同":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"进":{"docs":{},"栈":{"docs":{},"）":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"栈":{"docs":{},"也":{"docs":{},"只":{"docs":{},"能":{"docs":{},"从":{"docs":{},"末":{"docs":{},"端":{"docs":{},"移":{"docs":{},"除":{"docs":{},"项":{"docs":{},"（":{"docs":{},"如":{"docs":{},"同":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"d":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}}}},"如":{"docs":{},"何":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}},"单":{"docs":{},"例":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"压":{"docs":{},"了":{"docs":{},"三":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"进":{"docs":{},"栈":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"也":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"单":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"个":{"docs":{},"同":{"docs":{},"栈":{"docs":{},"里":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"即":{"docs":{},"便":{"docs":{},"栈":{"docs":{},"和":{"docs":{},"数":{"docs":{},"组":{"docs":{},"否":{"docs":{},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"他":{"docs":{},"们":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"他":{"docs":{},"们":{"docs":{},"都":{"docs":{},"包":{"docs":{},"含":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"。":{"docs":{},"你":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"用":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"作":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"函":{"docs":{},"数":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"显":{"docs":{},"示":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"同":{"docs":{},"创":{"docs":{},"建":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"其":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"任":{"docs":{},"何":{"docs":{},"有":{"docs":{},"效":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"栈":{"docs":{},"，":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"如":{"docs":{},"同":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"基":{"docs":{},"本":{"docs":{},"上":{"docs":{},"和":{"docs":{},"非":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"为":{"docs":{},"t":{"docs":{},"代":{"docs":{},"替":{"docs":{},"了":{"docs":{},"实":{"docs":{},"际":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"一":{"docs":{},"对":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"里":{"docs":{},"(":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"保":{"docs":{},"证":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"任":{"docs":{},"何":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"当":{"docs":{},"作":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.007518796992481203}}},"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0282021151586369},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.025089605734767026},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":2.3603238866396765},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.013363028953229399},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.05063291139240506},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.06741573033707865},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.05656565656565657},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.011857707509881422},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.018796992481203006},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.01046337817638266},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.008040201005025126},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}},"”":{"docs":{},"的":{"docs":{},"意":{"docs":{},"思":{"docs":{},"是":{"docs":{},"“":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"任":{"docs":{},"意":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"值":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"值":{"docs":{},"等":{"docs":{},"于":{"docs":{},"被":{"docs":{},"替":{"docs":{},"换":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"将":{"docs":{},"会":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"解":{"docs":{},"析":{"docs":{},"可":{"docs":{},"选":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"作":{"docs":{},"用":{"docs":{},"是":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"。":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"1":{"2":{"3":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"数":{"docs":{},"字":{"1":{"2":{"3":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"空":{"docs":{},"字":{"docs":{},"典":{"docs":{},"来":{"docs":{},"储":{"docs":{},"存":{"docs":{},"英":{"docs":{},"语":{"docs":{},"对":{"docs":{},"整":{"docs":{},"数":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"。":{"docs":{},"他":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"他":{"docs":{},"们":{"docs":{},"对":{"docs":{},"应":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"一":{"docs":{},"个":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"键":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"）":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"构":{"docs":{},"造":{"docs":{},"两":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"的":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"并":{"docs":{},"且":{"docs":{},"给":{"docs":{},"它":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"。":{"docs":{},"函":{"docs":{},"数":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"当":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"属":{"docs":{},"于":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"质":{"docs":{},"数":{"docs":{},"之":{"docs":{},"一":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"段":{"docs":{},"文":{"docs":{},"字":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"后":{"docs":{},"，":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"是":{"docs":{},"数":{"docs":{},"字":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"质":{"docs":{},"数":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"落":{"docs":{},"入":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"到":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"。":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"段":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"文":{"docs":{},"字":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},",":{"docs":{},"至":{"docs":{},"此":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"理":{"docs":{},"解":{"docs":{},"为":{"docs":{},"“":{"docs":{},"一":{"docs":{},"个":{"docs":{},"没":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"传":{"docs":{},"进":{"docs":{},"去":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"安":{"docs":{},"全":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"你":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}},"和":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"为":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"方":{"docs":{},"法":{"docs":{},"命":{"docs":{},"名":{"docs":{},"（":{"docs":{},"如":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"s":{"docs":{},")":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2564102564102564}}}}}}}}}}}}}},"t":{"docs":{},"f":{"docs":{},"-":{"8":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2564102564102564}}}}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}}}}}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},",":{"docs":{},"它":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"键":{"docs":{},"和":{"docs":{},"值":{"docs":{},"都":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}},"[":{"docs":{},"]":{"docs":{},"是":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}},"一":{"docs":{},"种":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}},"值":{"docs":{},"。":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"该":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"只":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"）":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"分":{"docs":{},"配":{"docs":{},"过":{"docs":{},"程":{"docs":{},"就":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"用":{"docs":{},"两":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"项":{"docs":{},"来":{"docs":{},"构":{"docs":{},"造":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"左":{"docs":{},"边":{"docs":{},"，":{"docs":{},"以":{"docs":{},"右":{"docs":{},"对":{"docs":{},"齐":{"docs":{},"到":{"docs":{},"总":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"中":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"存":{"docs":{},"在":{"docs":{},"局":{"docs":{},"部":{"docs":{},"常":{"docs":{},"量":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"中":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"多":{"docs":{},"的":{"docs":{},"填":{"docs":{},"充":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"）":{"docs":{},"字":{"docs":{},"符":{"docs":{},"填":{"docs":{},"充":{"docs":{},"到":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"左":{"docs":{},"边":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"。":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}},"?":{"docs":{},"。":{"docs":{},"如":{"docs":{},"上":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"后":{"docs":{},"最":{"docs":{},"终":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"依":{"docs":{},"然":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"l":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.016917293233082706},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0035252643948296123},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173}},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"？":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"在":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"前":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"两":{"docs":{},"层":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"，":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}},"a":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.012690355329949238},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"比":{"docs":{},"输":{"docs":{},"入":{"docs":{},"值":{"docs":{},"大":{"docs":{},"一":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"比":{"docs":{},"输":{"docs":{},"入":{"docs":{},"值":{"docs":{},"小":{"docs":{},"一":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"是":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}}}}}}}}}}}},"类":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"u":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"e":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}}}},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.06504065040650407}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"对":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"返":{"docs":{},"回":{"docs":{},"“":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"”":{"docs":{},"，":{"docs":{},"对":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"返":{"docs":{},"回":{"docs":{},"“":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"四":{"docs":{},"种":{"docs":{},"花":{"docs":{},"色":{"docs":{},"，":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"o":{"docs":{},"f":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"(":{"4":{"2":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}},"`":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992}}}}},"`":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"[":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"e":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"[":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.007905138339920948},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"（":{"docs":{},"子":{"docs":{},"类":{"docs":{},"化":{"docs":{},"？":{"docs":{},"待":{"docs":{},"定":{"docs":{},"）":{"docs":{},"重":{"docs":{},"写":{"docs":{},"（":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"访":{"docs":{},"问":{"docs":{},"超":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"及":{"docs":{},"下":{"docs":{},"标":{"docs":{},"重":{"docs":{},"写":{"docs":{},"方":{"docs":{},"法":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"变":{"docs":{},"成":{"docs":{},"父":{"docs":{},"类":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"超":{"docs":{},"类":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":10.005494505494505},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.29174443646805454},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},")":{"docs":{},"去":{"docs":{},"替":{"docs":{},"换":{"docs":{},"这":{"docs":{},"一":{"docs":{},"范":{"docs":{},"围":{"docs":{},"内":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"数":{"docs":{},"组":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"确":{"docs":{},"要":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"数":{"docs":{},"组":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"规":{"docs":{},"则":{"docs":{},"与":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"键":{"docs":{},"值":{"docs":{},"的":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"参":{"docs":{},"见":{"docs":{},"章":{"docs":{},"节":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.016483516483516484}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"入":{"docs":{},"参":{"docs":{},"（":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"）":{"docs":{},"和":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"与":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"下":{"docs":{},"标":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"定":{"docs":{},"为":{"docs":{},"读":{"docs":{},"写":{"docs":{},"或":{"docs":{},"只":{"docs":{},"读":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"又":{"docs":{},"有":{"docs":{},"点":{"docs":{},"像":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767}}}}}},"e":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}},"n":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}},"k":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.010025062656641603}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"是":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"遵":{"docs":{},"循":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794}}}}}}}},"y":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.008908685968819599}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"新":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"插":{"docs":{},"入":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"列":{"docs":{},"表":{"docs":{},"的":{"docs":{},"最":{"docs":{},"开":{"docs":{},"始":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"使":{"docs":{},"用":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.44040058622374206},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}},"r":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}},"docs":{}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{},"m":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}},"docs":{}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}},"docs":{}}}},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}},"docs":{}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"v":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}}}}}},"u":{"0":{"0":{"0":{"1":{"docs":{},"f":{"4":{"9":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"2":{"6":{"6":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"index.html#gitbook_101":{"ref":"index.html#gitbook_101","tf":0.06666666666666667},"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter1/chapter1.html#gitbook_106":{"ref":"chapter1/chapter1.html#gitbook_106","tf":0.25},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter2/chapter2.html#gitbook_166":{"ref":"chapter2/chapter2.html#gitbook_166","tf":0.3333333333333333},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.041666666666666664},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"值":{"docs":{},"的":{"docs":{},"下":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":1.0951898978214767},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.007518796992481203}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"2":{"1":{"docs":{},"位":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"是":{"2":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"和":{"docs":{},"变":{"docs":{},"体":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"体":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}},"标":{"docs":{},"签":{"docs":{},"联":{"docs":{},"合":{"docs":{},"（":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"w":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.010101010101010102},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.008960573476702509},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"确":{"docs":{},"定":{"docs":{},"数":{"docs":{},"组":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"性":{"docs":{},"。":{"docs":{},"(":{"docs":{},"当":{"docs":{},"数":{"docs":{},"组":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"常":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"后":{"docs":{},"再":{"docs":{},"修":{"docs":{},"改":{"docs":{},"b":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},",":{"docs":{},"b":{"docs":{},",":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"仅":{"docs":{},"会":{"docs":{},"在":{"docs":{},"确":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"时":{"docs":{},"才":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"数":{"docs":{},"组":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3069472634690026}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}},"i":{"docs":{},"k":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}}}},"r":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}},"p":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.024896265560165973},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},":":{"docs":{},")":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"。":{"docs":{},"举":{"docs":{},"例":{"docs":{},"来":{"docs":{},"说":{"docs":{},"：":{"docs":{},"对":{"docs":{},"于":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"或":{"docs":{},"者":{"docs":{},"更":{"docs":{},"新":{"docs":{},"特":{"docs":{},"定":{"docs":{},"键":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"就":{"docs":{},"像":{"docs":{},"上":{"docs":{},"面":{"docs":{},"所":{"docs":{},"示":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"现":{"docs":{},"有":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"你":{"docs":{},"并":{"docs":{},"不":{"docs":{},"能":{"docs":{},"传":{"docs":{},"入":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"只":{"docs":{},"能":{"docs":{},"传":{"docs":{},"入":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"进":{"docs":{},"行":{"docs":{},"相":{"docs":{},"加":{"docs":{},"。":{"docs":{},"目":{"docs":{},"标":{"docs":{},"常":{"docs":{},"量":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"推":{"docs":{},"测":{"docs":{},"为":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"是":{"docs":{},"两":{"docs":{},"个":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"3":{"2":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"层":{"docs":{},"叠":{"docs":{},"样":{"docs":{},"式":{"docs":{},"表":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"中":{"docs":{},"粉":{"docs":{},"色":{"docs":{},"的":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"，":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"#":{"docs":{},"c":{"docs":{},"c":{"6":{"6":{"9":{"9":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"用":{"docs":{},"十":{"docs":{},"六":{"docs":{},"进":{"docs":{},"制":{"0":{"docs":{},"x":{"docs":{},"c":{"docs":{},"c":{"6":{"6":{"9":{"9":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"使":{"docs":{},"用":{"docs":{},"按":{"docs":{},"位":{"docs":{},"与":{"docs":{},"(":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},")":{"docs":{},"和":{"docs":{},"按":{"docs":{},"位":{"docs":{},"右":{"docs":{},"移":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"这":{"docs":{},"个":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"中":{"docs":{},"解":{"docs":{},"析":{"docs":{},"出":{"docs":{},"红":{"docs":{},"(":{"docs":{},"c":{"docs":{},"c":{"docs":{},")":{"docs":{},"，":{"docs":{},"绿":{"docs":{},"(":{"6":{"6":{"docs":{},")":{"docs":{},"，":{"docs":{},"蓝":{"docs":{},"(":{"9":{"9":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"8":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.008960573476702509},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005875440658049354}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"是":{"8":{"docs":{},"位":{"docs":{},"无":{"docs":{},"符":{"docs":{},"整":{"docs":{},"型":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"0":{"docs":{},"~":{"2":{"5":{"5":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"为":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"值":{"0":{"0":{"0":{"0":{"1":{"1":{"1":{"1":{"docs":{},"(":{"docs":{},"前":{"4":{"docs":{},"位":{"docs":{},"为":{"0":{"docs":{},"，":{"docs":{},"后":{"4":{"docs":{},"位":{"docs":{},"为":{"1":{"docs":{},")":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"值":{"docs":{},"为":{"1":{"5":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}}},"docs":{}}}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}},"docs":{}},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"值":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{},"是":{"0":{"docs":{},"(":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"为":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"-":{"docs":{},"进":{"docs":{},"行":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"减":{"1":{"docs":{},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"2":{"5":{"5":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"docs":{}}}}}}},"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"你":{"docs":{},"真":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"存":{"docs":{},"储":{"docs":{},"一":{"docs":{},"个":{"docs":{},"和":{"docs":{},"当":{"docs":{},"前":{"docs":{},"平":{"docs":{},"台":{"docs":{},"原":{"docs":{},"生":{"docs":{},"字":{"docs":{},"长":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"无":{"docs":{},"符":{"docs":{},"号":{"docs":{},"整":{"docs":{},"数":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"最":{"docs":{},"好":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"你":{"docs":{},"要":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"值":{"docs":{},"已":{"docs":{},"知":{"docs":{},"是":{"docs":{},"非":{"docs":{},"负":{"docs":{},"的":{"docs":{},"。":{"docs":{},"统":{"docs":{},"一":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}},"+":{"0":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"2":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{},"a":{"8":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"b":{"2":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"5":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}}},"docs":{}},"docs":{}}}}},"7":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{},"c":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}}}}}},"c":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"d":{"6":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}}},"docs":{}},"docs":{}}}}},"docs":{}},"d":{"8":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"f":{"6":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}}},"docs":{}},"docs":{}}}}},"docs":{}},"f":{"8":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"3":{"6":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"7":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"6":{"7":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"1":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"8":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"8":{"0":{"docs":{},"f":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"docs":{}}}}}},"docs":{}},"docs":{},"f":{"4":{"3":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}},"docs":{}},"9":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}},"d":{"docs":{},"c":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"docs":{}}}}},"docs":{}}},"e":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"docs":{}}}}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{},"b":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"a":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"2":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"docs":{}},"docs":{}}}}}},"3":{"docs":{},"f":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"4":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"5":{"4":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"6":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"6":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"7":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"docs":{},"c":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{},"d":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"1":{"8":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"4":{"6":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"4":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"6":{"6":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"7":{"7":{"6":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"7":{"9":{"3":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{},"c":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"e":{"8":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"docs":{}}}}},"docs":{}},"docs":{}}},"3":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"4":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"0":{"7":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"2":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"2":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"3":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"3":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"4":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"d":{"7":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"4":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"4":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"5":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"6":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"7":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"8":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"9":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"d":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}},"docs":{}},"docs":{}},"a":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"b":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"b":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"c":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"c":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"f":{"9":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"d":{"3":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{},"d":{"4":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"d":{"docs":{},"c":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}},"docs":{}},"docs":{},"f":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"1":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}}}}}}},"docs":{}}},"e":{"2":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"2":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"docs":{}}}}}}},"docs":{}},"3":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"4":{"4":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"docs":{}},"docs":{}}}}}}},"docs":{}},"4":{"7":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}},"docs":{}},"docs":{}}}},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.013438735177865613},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.008225616921269096},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}},"t":{"docs":{},"f":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}}}}}}}}}}}}},"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503}},"(":{"docs":{},"以":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.011278195488721804}},"(":{"docs":{},"以":{"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}}}},"docs":{}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}},"w":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"w":{"docs":{},"d":{"docs":{},"c":{"docs":{"index.html#gitbook_101":{"ref":"index.html#gitbook_101","tf":0.06666666666666667}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}}},"r":{"docs":{},"m":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"，":{"docs":{},"只":{"docs":{},"在":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"后":{"docs":{},"面":{"docs":{},"写":{"docs":{},"接":{"docs":{},"口":{"docs":{},"或":{"docs":{},"者":{"docs":{},"类":{"docs":{},"名":{"docs":{},"。":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"队":{"docs":{},"列":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"使":{"docs":{},"你":{"docs":{},"能":{"docs":{},"够":{"docs":{},"要":{"docs":{},"求":{"docs":{},"一":{"docs":{},"个":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"（":{"docs":{},"或":{"docs":{},"）":{"docs":{},"那":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"放":{"docs":{},"置":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"写":{"docs":{},"在":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}},"。":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"由":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"明":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"某":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"有":{"docs":{},"助":{"docs":{},"于":{"docs":{},"表":{"docs":{},"达":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"上":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"约":{"docs":{},"束":{"docs":{},"（":{"docs":{},"如":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"­":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.024896265560165973}}}},"n":{"docs":{},"e":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"条":{"docs":{},"件":{"docs":{},"语":{"docs":{},"句":{"docs":{},"i":{"docs":{},"f":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"贯":{"docs":{},"穿":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.6666666666666665}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"方":{"docs":{},"法":{"docs":{},"块":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}},"语":{"docs":{},"法":{"docs":{},"，":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"规":{"docs":{},"则":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"t":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.017766497461928935},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"=":{"docs":{},"\"":{"1":{"6":{"9":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"docs":{}},"docs":{}},"2":{"4":{"3":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}},"5":{"2":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"docs":{}},"8":{"8":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}},"9":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}},"docs":{}},"3":{"8":{"8":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}}},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"两":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939}}}},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"实":{"docs":{},"现":{"docs":{},"是":{"docs":{},"不":{"docs":{},"恰":{"docs":{},"当":{"docs":{},"。":{"docs":{},"此":{"docs":{},"外":{"docs":{},"还":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"你":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"同":{"docs":{},"时":{"docs":{},"提":{"docs":{},"供":{"docs":{},"重":{"docs":{},"写":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"重":{"docs":{},"写":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"观":{"docs":{},"察":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"的":{"docs":{},"变":{"docs":{},"化":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"你":{"docs":{},"已":{"docs":{},"经":{"docs":{},"为":{"docs":{},"那":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"你":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"会":{"docs":{},"将":{"docs":{},"新":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"固":{"docs":{},"定":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"，":{"docs":{},"在":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"指":{"docs":{},"定":{"docs":{},"则":{"docs":{},"参":{"docs":{},"数":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"名":{"docs":{},"称":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"表":{"docs":{},"示":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"所":{"docs":{},"能":{"docs":{},"承":{"docs":{},"载":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"值":{"2":{"5":{"5":{"docs":{},"(":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"docs":{},")":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"用":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"+":{"docs":{},"加":{"1":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"就":{"docs":{},"无":{"docs":{},"法":{"docs":{},"表":{"docs":{},"达":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"了":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"导":{"docs":{},"致":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"上":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"了":{"docs":{},"，":{"docs":{},"大":{"docs":{},"家":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"下":{"docs":{},"图":{"docs":{},"。":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"后":{"docs":{},"，":{"docs":{},"新":{"docs":{},"值":{"docs":{},"在":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"的":{"docs":{},"承":{"docs":{},"载":{"docs":{},"范":{"docs":{},"围":{"docs":{},"内":{"docs":{},"的":{"docs":{},"那":{"docs":{},"部":{"docs":{},"分":{"docs":{},"是":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"docs":{}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}}}}}}}}},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.28671931083991387},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}}},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"参":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.4679292185915677},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.8747066055661116},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.01969057665260197},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.01832460732984293},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.006060606060606061},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"<":{"docs":{},"/":{"docs":{},"p":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}},"k":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.260169654906497},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.011834319526627219}}}},"e":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.007853403141361256}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}},"e":{"docs":{},"变":{"docs":{},"量":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"注":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"'":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.010128913443830571}}},"k":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"或":{"docs":{},"者":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"和":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"(":{"docs":{},"如":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"或":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939}}}},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"a":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"a":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"4":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},"b":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"从":{"docs":{},"a":{"docs":{},"到":{"docs":{},"b":{"docs":{},"(":{"docs":{},"包":{"docs":{},"括":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"从":{"docs":{},"a":{"docs":{},"到":{"docs":{},"b":{"docs":{},"但":{"docs":{},"不":{"docs":{},"包":{"docs":{},"括":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.024390243902439025}},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"t":{"1":{"docs":{},"s":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}}}}}}}}}}}},"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.02443609022556391}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}},"e":{"docs":{},"r":{"docs":{},"常":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"它":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"可":{"docs":{},"选":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"!":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"d":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"o":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"过":{"docs":{},"程":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"都":{"docs":{},"传":{"docs":{},"入":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},"(":{"5":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}},"docs":{}}}},"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.023178807947019868}},"。":{"docs":{},"它":{"docs":{},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"他":{"docs":{},"们":{"docs":{},"额":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"？":{"docs":{},"。":{"docs":{},"前":{"docs":{},"面":{"docs":{},"两":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"（":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"它":{"docs":{},"获":{"docs":{},"取":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"？":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"检":{"docs":{},"查":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"有":{"docs":{},"值":{"docs":{},"则":{"docs":{},"将":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"如":{"docs":{},"果":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"并":{"docs":{},"为":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.008617312965139052}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.007050528789659225}}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.008426966292134831},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.007712082262210797},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"并":{"docs":{},"存":{"docs":{},"储":{"docs":{},"了":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"副":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"该":{"docs":{},"副":{"docs":{},"本":{"docs":{},"随":{"docs":{},"着":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"者":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"在":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"每":{"docs":{},"次":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"地":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"只":{"docs":{},"把":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"当":{"docs":{},"作":{"docs":{},"一":{"docs":{},"个":{"docs":{},"局":{"docs":{},"部":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"把":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"p":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.00626713670191931},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.007035175879396985},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},";":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.007853403141361256},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},";":{"docs":{},"和":{"docs":{},"|":{"docs":{},"|":{"docs":{},"的":{"docs":{},"复":{"docs":{},"合":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{},"但":{"docs":{},"无":{"docs":{},"论":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"，":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"和":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"%":{"docs":{},"进":{"docs":{},"行":{"docs":{},"除":{"0":{"docs":{},"操":{"docs":{},"作":{"docs":{},"时":{"docs":{},"就":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"进":{"docs":{},"行":{"docs":{},"组":{"docs":{},"合":{"docs":{},",":{"docs":{},"称":{"docs":{},"为":{"docs":{},"协":{"docs":{},"议":{"docs":{},"合":{"docs":{},"成":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"2":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.007032348804500703},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.01195814648729447}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.009486166007905139},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8333333333333333}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"代":{"docs":{},"表":{"docs":{},"任":{"docs":{},"何":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"除":{"docs":{},"了":{"docs":{},"方":{"docs":{},"法":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}},"s":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}},"n":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}},"o":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}},"s":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"2":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}},"p":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.013363028953229399}},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01818181818181818},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{},"插":{"docs":{},"入":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{},"删":{"docs":{},"除":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{},"范":{"docs":{},"围":{"docs":{},"下":{"docs":{},"标":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}}}}},"方":{"docs":{},"法":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"一":{"docs":{},"般":{"docs":{},"接":{"docs":{},"收":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"]":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"说":{"docs":{},"“":{"docs":{},"一":{"docs":{},"个":{"docs":{},"任":{"docs":{},"何":{"docs":{},"对":{"docs":{},"象":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"”":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"o":{"docs":{},"c":{"docs":{},"没":{"docs":{},"有":{"docs":{},"明":{"docs":{},"确":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"化":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"你":{"docs":{},"常":{"docs":{},"常":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"定":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"仅":{"docs":{},"从":{"docs":{},"你":{"docs":{},"知":{"docs":{},"道":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.022222222222222223},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}},"实":{"docs":{},"例":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"的":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"来":{"docs":{},"自":{"docs":{},"于":{"docs":{},"变":{"docs":{},"量":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"这":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.010025062656641603},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"c":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}},"为":{"docs":{},"了":{"docs":{},"能":{"docs":{},"帮":{"docs":{},"助":{"docs":{},"你":{"docs":{},"管":{"docs":{},"理":{"docs":{},"内":{"docs":{},"存":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"更":{"docs":{},"多":{"docs":{},"的":{"docs":{},"关":{"docs":{},"于":{"docs":{},"你":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"之":{"docs":{},"间":{"docs":{},"关":{"docs":{},"系":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"本":{"docs":{},"章":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"这":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"为":{"docs":{},"你":{"docs":{},"示":{"docs":{},"范":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"启":{"docs":{},"用":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"分":{"docs":{},"配":{"docs":{},"一":{"docs":{},"大":{"docs":{},"块":{"docs":{},"内":{"docs":{},"存":{"docs":{},"用":{"docs":{},"来":{"docs":{},"储":{"docs":{},"存":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"。":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"会":{"docs":{},"包":{"docs":{},"含":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"这":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"所":{"docs":{},"有":{"docs":{},"相":{"docs":{},"关":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"此":{"docs":{},"外":{"docs":{},"，":{"docs":{},"当":{"docs":{},"实":{"docs":{},"例":{"docs":{},"不":{"docs":{},"再":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"后":{"docs":{},"自":{"docs":{},"动":{"docs":{},"将":{"docs":{},"其":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"三":{"docs":{},"个":{"docs":{},"，":{"docs":{},"也":{"docs":{},"即":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"被":{"docs":{},"断":{"docs":{},"开":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"你":{"docs":{},"不":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"跟":{"docs":{},"踪":{"docs":{},"你":{"docs":{},"所":{"docs":{},"新":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"会":{"docs":{},"在":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"计":{"docs":{},"算":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"正":{"docs":{},"在":{"docs":{},"被":{"docs":{},"多":{"docs":{},"少":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"常":{"docs":{},"量":{"docs":{},"和":{"docs":{},"变":{"docs":{},"量":{"docs":{},"所":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"哪":{"docs":{},"怕":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"数":{"docs":{},"为":{"docs":{},"一":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"无":{"docs":{},"法":{"docs":{},"在":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"后":{"docs":{},"将":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"设":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"非":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"销":{"docs":{},"毁":{"docs":{},"被":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"行":{"docs":{},"为":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"了":{"docs":{},"引":{"docs":{},"用":{"docs":{},"变":{"docs":{},"为":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"声":{"docs":{},"明":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"w":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"3":{"docs":{},"d":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"[":{"0":{"docs":{},"]":{"docs":{},"是":{"docs":{},"指":{"docs":{},"[":{"docs":{},"[":{"1":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}},"docs":{}}}}}}},"docs":{}}}},"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}},"替":{"docs":{},"代":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}},"类":{"docs":{},"型":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"特":{"docs":{},"定":{"docs":{},"大":{"docs":{},"小":{"docs":{},"并":{"docs":{},"且":{"docs":{},"所":{"docs":{},"有":{"docs":{},"数":{"docs":{},"据":{"docs":{},"都":{"docs":{},"被":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"把":{"docs":{},"准":{"docs":{},"备":{"docs":{},"加":{"docs":{},"入":{"docs":{},"新":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"数":{"docs":{},"量":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"和":{"docs":{},"适":{"docs":{},"当":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"，":{"docs":{},"范":{"docs":{},"围":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"和":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"行":{"docs":{},"为":{"docs":{},"要":{"docs":{},"比":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"多":{"docs":{},"。":{"docs":{},"当":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"组":{"docs":{},"内":{"docs":{},"容":{"docs":{},"时":{"docs":{},"，":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},")":{"docs":{},"能":{"docs":{},"提":{"docs":{},"供":{"docs":{},"接":{"docs":{},"近":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}},"性":{"docs":{},"质":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"存":{"docs":{},"储":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"提":{"docs":{},"供":{"docs":{},"两":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"，":{"docs":{},"从":{"docs":{},"栈":{"docs":{},"中":{"docs":{},"压":{"docs":{},"进":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"和":{"docs":{},"移":{"docs":{},"除":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"（":{"docs":{},"或":{"docs":{},"转":{"docs":{},"换":{"docs":{},"）":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.020553359683794466},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4375915974596971},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.012060301507537688},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"y":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}},"i":{"docs":{},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}},"3":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}}}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}},"o":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}},"x":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.008695652173913044}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987}},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"就":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"地":{"docs":{},"设":{"docs":{},"置":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"为":{"docs":{},"新":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"。":{"docs":{},"具":{"docs":{},"体":{"docs":{},"来":{"docs":{},"说":{"docs":{},"就":{"docs":{},"是":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"将":{"docs":{},"新":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"值":{"docs":{},"除":{"docs":{},"以":{"1":{"0":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"向":{"docs":{},"下":{"docs":{},"取":{"docs":{},"得":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"最":{"docs":{},"后":{"docs":{},"加":{"1":{"docs":{},"来":{"docs":{},"得":{"docs":{},"到":{"docs":{},"档":{"docs":{},"位":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"速":{"docs":{},"度":{"docs":{},"为":{"1":{"0":{"docs":{},".":{"0":{"docs":{},"时":{"docs":{},"，":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"为":{"1":{"docs":{},"；":{"docs":{},"速":{"docs":{},"度":{"docs":{},"为":{"3":{"5":{"docs":{},".":{"0":{"docs":{},"时":{"docs":{},"，":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"为":{"4":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}},"docs":{}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}},"docs":{}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"。":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"表":{"docs":{},"示":{"docs":{},"自":{"docs":{},"动":{"docs":{},"挡":{"docs":{},"汽":{"docs":{},"车":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"根":{"docs":{},"据":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"自":{"docs":{},"动":{"docs":{},"选":{"docs":{},"择":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"。":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.02197802197802198},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"见":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"章":{"docs":{},"节":{"docs":{},"）":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"动":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"函":{"docs":{},"数":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"特":{"docs":{},"定":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"上":{"docs":{},"的":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"而":{"docs":{},"非":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"别":{"docs":{},"名":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"是":{"docs":{},"别":{"docs":{},"名":{"docs":{},"，":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"会":{"docs":{},"给":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"赋":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"值":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.009398496240601503}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}}}}}}}},"也":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"表":{"docs":{},"示":{"docs":{},"立":{"docs":{},"体":{"docs":{},"声":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"声":{"docs":{},"道":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"和":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.007518796992481203}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"储":{"docs":{},"存":{"docs":{},"了":{"docs":{},"四":{"docs":{},"个":{"docs":{},"人":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"年":{"docs":{},"龄":{"docs":{},"。":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"在":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"，":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"断":{"docs":{},"言":{"docs":{},"。":{"docs":{},"给":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"函":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"条":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"当":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}}}}}}}}},"i":{"docs":{},"g":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3108642239077022},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.3007896625987078}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"把":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"左":{"docs":{},"参":{"docs":{},"数":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3116476159954421},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"—":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},"的":{"docs":{},"值":{"docs":{},"可":{"docs":{},"取":{"docs":{},"的":{"docs":{},"值":{"docs":{},"有":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"，":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"，":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"1":{"0":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"和":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"、":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"、":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"、":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"、":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"、":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"、":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"、":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},")":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},")":{"docs":{},"、":{"docs":{},"w":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"、":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"型":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"元":{"docs":{},"素":{"docs":{},"确":{"docs":{},"实":{"docs":{},"需":{"docs":{},"要":{"docs":{},"处":{"docs":{},"理":{"docs":{},"为":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"输":{"docs":{},"出":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"时":{"docs":{},"，":{"docs":{},"才":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"在":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"完":{"docs":{},"成":{"docs":{},"以":{"docs":{},"及":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"确":{"docs":{},"实":{"docs":{},"存":{"docs":{},"在":{"docs":{},"后":{"docs":{},"，":{"docs":{},"才":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"由":{"docs":{},"于":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"是":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"改":{"docs":{},"变":{"docs":{},"特":{"docs":{},"定":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"持":{"docs":{},"有":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"在":{"docs":{},"其":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"体":{"docs":{},"内":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"（":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"占":{"docs":{},"有":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"又":{"docs":{},"反":{"docs":{},"过":{"docs":{},"来":{"docs":{},"持":{"docs":{},"有":{"docs":{},"了":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"两":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"就":{"docs":{},"产":{"docs":{},"生":{"docs":{},"了":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"（":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"占":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"代":{"docs":{},"表":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"标":{"docs":{},"签":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"值":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"该":{"docs":{},"标":{"docs":{},"签":{"docs":{},"就":{"docs":{},"包":{"docs":{},"含":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"该":{"docs":{},"标":{"docs":{},"签":{"docs":{},"就":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"文":{"docs":{},"本":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"段":{"docs":{},"落":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"根":{"docs":{},"据":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"是":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"下":{"docs":{},"转":{"docs":{},"并":{"docs":{},"解":{"docs":{},"包":{"docs":{},"到":{"docs":{},"不":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"p":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}},"?":{"docs":{},")":{"docs":{},"。":{"docs":{},"可":{"docs":{},"选":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"总":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},",":{"docs":{},"当":{"docs":{},"实":{"docs":{},"例":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},",":{"docs":{},"返":{"docs":{},"回":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"类":{"docs":{},"型":{"docs":{},";":{"docs":{},"否":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}}}}},"­":{"docs":{},"?":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"、":{"docs":{},"i":{"docs":{},"s":{"docs":{},"、":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"、":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"、":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"_":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"右":{"docs":{},"边":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"那":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.035634743875278395}},"'":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.017817371937639197}}}}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"[":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"l":{"docs":{},"h":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}}}},"字":{"docs":{},"典":{"docs":{},"使":{"docs":{},"用":{"docs":{},"字":{"docs":{},"典":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"对":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"t":{"docs":{},"y":{"docs":{},"o":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"y":{"docs":{},"o":{"docs":{},"。":{"docs":{},"第":{"docs":{},"二":{"docs":{},"对":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"）":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"一":{"docs":{},"种":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.054945054945054944},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0205761316872428}},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.02197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}},"i":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"g":{"docs":{},"n":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}},"函":{"docs":{},"数":{"docs":{},"将":{"docs":{},"参":{"docs":{},"数":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"变":{"docs":{},"量":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"右":{"docs":{},"对":{"docs":{},"齐":{"docs":{},"输":{"docs":{},"入":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"长":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"中":{"docs":{},"。":{"docs":{},"左":{"docs":{},"侧":{"docs":{},"空":{"docs":{},"余":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"用":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"填":{"docs":{},"充":{"docs":{},"字":{"docs":{},"符":{"docs":{},"填":{"docs":{},"充":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"e":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}},"s":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}}},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"对":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}},"=":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"两":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"单":{"docs":{},"例":{"docs":{},"包":{"docs":{},"含":{"docs":{},"具":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"的":{"docs":{},"相":{"docs":{},"同":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"首":{"docs":{},"先":{"docs":{},"检":{"docs":{},"查":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"是":{"docs":{},"否":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"数":{"docs":{},"目":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"数":{"docs":{},"目":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"办":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"就":{"docs":{},"会":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}},"w":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"g":{"docs":{},"h":{"docs":{},"i":{"docs":{},"j":{"docs":{},"k":{"docs":{},"l":{"docs":{},"m":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},",":{"docs":{},"b":{"docs":{},",":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}}}}},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}},"docs":{}},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"值":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"a":{"docs":{},"将":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"与":{"docs":{},"b":{"docs":{},"，":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}},"+":{"docs":{},"+":{"docs":{},"，":{"docs":{},"是":{"docs":{},"先":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"a":{"docs":{},"才":{"docs":{},"加":{"1":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"得":{"docs":{},"到":{"docs":{},"了":{"docs":{},"a":{"docs":{},"的":{"docs":{},"旧":{"docs":{},"值":{"1":{"docs":{},"，":{"docs":{},"而":{"docs":{},"a":{"docs":{},"加":{"1":{"docs":{},"后":{"docs":{},"变":{"docs":{},"成":{"2":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"docs":{}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},".":{"docs":{},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"。":{"docs":{},"一":{"docs":{},"目":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"分":{"docs":{},"前":{"docs":{},"置":{"docs":{},"符":{"docs":{},"和":{"docs":{},"后":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"前":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"需":{"docs":{},"紧":{"docs":{},"排":{"docs":{},"操":{"docs":{},"作":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"如":{"docs":{},"!":{"docs":{},"b":{"docs":{},"，":{"docs":{},"后":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"需":{"docs":{},"紧":{"docs":{},"跟":{"docs":{},"操":{"docs":{},"作":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"如":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"都":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"时":{"docs":{},"，":{"docs":{},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"才":{"docs":{},"会":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"一":{"docs":{},"个":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"取":{"docs":{},"反":{"docs":{},"，":{"docs":{},"使":{"docs":{},"得":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"变":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"变":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"先":{"docs":{},"把":{"docs":{},"a":{"docs":{},"加":{"1":{"docs":{},"了":{"docs":{},"再":{"docs":{},"返":{"docs":{},"回":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"都":{"docs":{},"是":{"docs":{},"新":{"docs":{},"值":{"1":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}},"？":{"docs":{},"b":{"docs":{},"：":{"docs":{},"c":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}}},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.014064697609001406},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.05759162303664921},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.02391629297458894},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.011695906432748537},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}},"二":{"docs":{},"十":{"docs":{},"一":{"docs":{},"点":{"docs":{},")":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"模":{"docs":{},"拟":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"中":{"docs":{},"的":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"点":{"docs":{},"数":{"docs":{},"。":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"包":{"docs":{},"含":{"2":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"没":{"docs":{},"有":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"在":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"自":{"docs":{},"身":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"—":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"与":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"，":{"docs":{},"也":{"docs":{},"同":{"docs":{},"样":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"用":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"和":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"的":{"docs":{},"中":{"docs":{},"内":{"docs":{},"容":{"docs":{},"来":{"docs":{},"构":{"docs":{},"建":{"docs":{},"对":{"docs":{},"这":{"docs":{},"张":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"数":{"docs":{},"值":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"并":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"规":{"docs":{},"则":{"docs":{},"中":{"docs":{},"，":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"牌":{"docs":{},"可":{"docs":{},"以":{"docs":{},"表":{"docs":{},"示":{"1":{"docs":{},"或":{"docs":{},"者":{"1":{"1":{"docs":{},"，":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"这":{"docs":{},"一":{"docs":{},"特":{"docs":{},"征":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"在":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"型":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.08333333333333333}}}}}},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.02247191011235955},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.007712082262210797},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"。":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"是":{"docs":{},"指":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"只":{"docs":{},"能":{"docs":{},"是":{"docs":{},"真":{"docs":{},"或":{"docs":{},"者":{"docs":{},"假":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"非":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"默":{"docs":{},"认":{"docs":{},"都":{"docs":{},"是":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"h":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0055248618784530384},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}},"）":{"docs":{},"，":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}},"[":{"0":{"3":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"6":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"9":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}},"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"1":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"4":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}},"9":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}},"2":{"2":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}},"4":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"6":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}},"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}},"d":{"docs":{},"i":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"y":{"docs":{},")":{"docs":{},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"指":{"docs":{},"向":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"[":{"0":{"9":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}},"1":{"4":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}},"2":{"2":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498}},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"类":{"docs":{},"是":{"docs":{},"在":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"创":{"docs":{},"建":{"docs":{},"起":{"docs":{},"来":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"放":{"docs":{},"在":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"仅":{"docs":{},"可":{"docs":{},"以":{"docs":{},"继":{"docs":{},"承":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"继":{"docs":{},"承":{"docs":{},"它":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"超":{"docs":{},"类":{"docs":{},"。":{"docs":{},"新":{"docs":{},"的":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"自":{"docs":{},"动":{"docs":{},"获":{"docs":{},"得":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"子":{"docs":{},"类":{"docs":{},"中":{"docs":{},"定":{"docs":{},"制":{"docs":{},"这":{"docs":{},"些":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"或":{"docs":{},"添":{"docs":{},"加":{"docs":{},"新":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"来":{"docs":{},"更":{"docs":{},"好":{"docs":{},"地":{"docs":{},"描":{"docs":{},"述":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"：":{"docs":{},"双":{"docs":{},"人":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"（":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"）":{"docs":{},"。":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"从":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"而":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"从":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"继":{"docs":{},"承":{"docs":{},"而":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{},"并":{"docs":{},"不":{"docs":{},"修":{"docs":{},"改":{"docs":{},"轮":{"docs":{},"子":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"仍":{"docs":{},"是":{"docs":{},"一":{"docs":{},"辆":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"，":{"docs":{},"有":{"2":{"docs":{},"个":{"docs":{},"轮":{"docs":{},"子":{"docs":{},"。":{"docs":{},"但":{"docs":{},"它":{"docs":{},"需":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"它":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"（":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"只":{"docs":{},"有":{"2":{"docs":{},"个":{"docs":{},"轮":{"docs":{},"子":{"docs":{},"）":{"docs":{},"。":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"它":{"docs":{},"父":{"docs":{},"类":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"确":{"docs":{},"保":{"docs":{},"在":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"试":{"docs":{},"图":{"docs":{},"修":{"docs":{},"改":{"docs":{},"那":{"docs":{},"些":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"前":{"docs":{},"，":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0054869684499314125}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005483744614179397},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.28671931083991387}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},")":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"控":{"docs":{},"制":{"docs":{},"转":{"docs":{},"移":{"docs":{},"语":{"docs":{},"句":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.6666666666666665}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"9":{"docs":{},"试":{"docs":{},"图":{"docs":{},"访":{"docs":{},"问":{"docs":{},"一":{"docs":{},"个":{"docs":{},"行":{"docs":{},"星":{"docs":{},"。":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}},"docs":{}}}}}}},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}},")":{"docs":{},"到":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}},"自":{"docs":{},"动":{"docs":{},"拆":{"docs":{},"包":{"docs":{},"并":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"常":{"docs":{},"量":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.021151586368977675},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"-":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3139977922586618},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.009045226130653266}}}}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}}},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}}}},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.04142011834319527}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.01775147928994083}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.011834319526627219}}}}}}}}}}}}}}}}},"和":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"管":{"docs":{},"理":{"docs":{},"一":{"docs":{},"个":{"docs":{},"虚":{"docs":{},"拟":{"docs":{},"货":{"docs":{},"币":{"docs":{},"的":{"docs":{},"流":{"docs":{},"通":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"流":{"docs":{},"通":{"docs":{},"中":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"永":{"docs":{},"远":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"超":{"docs":{},"过":{"1":{"0":{"docs":{},",":{"0":{"0":{"0":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"有":{"docs":{},"且":{"docs":{},"只":{"docs":{},"能":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"根":{"docs":{},"据":{"docs":{},"它":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"跟":{"docs":{},"踪":{"docs":{},"当":{"docs":{},"前":{"docs":{},"它":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"数":{"docs":{},"量":{"docs":{},"。":{"docs":{},"银":{"docs":{},"行":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"两":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"—":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"和":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"i":{"docs":{},"c":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}},"c":{"docs":{},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.011235955056179775}},"s":{"docs":{},"(":{"docs":{},"s":{"1":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}},"docs":{}}}}}}}},"s":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"(":{"8":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"docs":{}},"和":{"docs":{},"其":{"docs":{},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"被":{"docs":{},"新":{"docs":{},"的":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"q":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"和":{"docs":{},"其":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"值":{"docs":{},"所":{"docs":{},"替":{"docs":{},"代":{"docs":{},"。":{"docs":{},"条":{"docs":{},"形":{"docs":{},"码":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"和":{"docs":{},"变":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"一":{"docs":{},"个":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"或":{"docs":{},"者":{"docs":{},"一":{"docs":{},"个":{"docs":{},".":{"docs":{},"q":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"q":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.07692307692307693},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00823045267489712}},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.054945054945054944}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.03636363636363636},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.4373533027830558},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.6103692625431756}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"t":{"docs":{},"o":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"o":{"docs":{},"w":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.004700352526439483}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.009933774834437087}},"e":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"不":{"docs":{},"是":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.009933774834437087}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.009933774834437087}},"e":{"docs":{},"r":{"docs":{},"作":{"docs":{},"为":{"docs":{},"地":{"docs":{},"址":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"是":{"docs":{},"定":{"docs":{},"义":{"docs":{},"某":{"docs":{},"个":{"docs":{},"建":{"docs":{},"筑":{"docs":{},"物":{"docs":{},"的":{"docs":{},"两":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"第":{"docs":{},"三":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":5.010989010989011}},"特":{"docs":{},"性":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}},"：":{"docs":{},"i":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"i":{"docs":{},"b":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"i":{"docs":{},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"特":{"docs":{},"性":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"与":{"docs":{},"x":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"同":{"docs":{},"步":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"以":{"docs":{},"下":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.008287292817679558},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.014245014245014245},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},",":{"docs":{},"和":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"立":{"docs":{},"刻":{"docs":{},"结":{"docs":{},"束":{"docs":{},"整":{"docs":{},"个":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"更":{"docs":{},"早":{"docs":{},"的":{"docs":{},"结":{"docs":{},"束":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"或":{"docs":{},"者":{"docs":{},"一":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"将":{"docs":{},"会":{"docs":{},"中":{"docs":{},"断":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"清":{"docs":{},"晰":{"docs":{},"的":{"docs":{},"表":{"docs":{},"明":{"docs":{},"了":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"、":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"和":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"面":{"docs":{},"带":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"终":{"docs":{},"止":{"docs":{},"由":{"docs":{},"这":{"docs":{},"个":{"docs":{},"标":{"docs":{},"签":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"或":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"可":{"docs":{},"以":{"docs":{},"改":{"docs":{},"变":{"docs":{},"循":{"docs":{},"环":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"。":{"docs":{},"有":{"docs":{},"关":{"docs":{},"这":{"docs":{},"两":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"终":{"docs":{},"止":{"docs":{},"循":{"docs":{},"环":{"docs":{},"或":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"写":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"这":{"docs":{},"个":{"docs":{},"关":{"docs":{},"键":{"docs":{},"词":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"一":{"docs":{},"章":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"会":{"docs":{},"发":{"docs":{},"生":{"docs":{},"这":{"docs":{},"种":{"docs":{},"“":{"docs":{},"掉":{"docs":{},"入":{"docs":{},"”":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"、":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"、":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"、":{"docs":{},"d":{"docs":{},"o":{"docs":{},"、":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"、":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"、":{"docs":{},"i":{"docs":{},"f":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"、":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"、":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"、":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"、":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"、":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"终":{"docs":{},"止":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"或":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"用":{"docs":{},"于":{"docs":{},"终":{"docs":{},"止":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},".":{"docs":{},".":{"docs":{},".":{"1":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}},"docs":{}}}}},"docs":{}},"和":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"都":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"此":{"docs":{},"时":{"docs":{},"在":{"docs":{},"b":{"docs":{},"上":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"则":{"docs":{},"会":{"docs":{},"将":{"docs":{},"b":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{},"提":{"docs":{},"示":{"docs":{},"<":{"docs":{},"/":{"docs":{},"b":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099}}}}}}}},"求":{"docs":{},"余":{"docs":{},"时":{"docs":{},"，":{"docs":{},"-":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}},"的":{"docs":{},"多":{"docs":{},"少":{"docs":{},"倍":{"docs":{},"刚":{"docs":{},"刚":{"docs":{},"好":{"docs":{},"可":{"docs":{},"以":{"docs":{},"容":{"docs":{},"入":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"用":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"或":{"docs":{},"更":{"docs":{},"新":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"c":{"1":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"同":{"docs":{},"样":{"docs":{},"是":{"docs":{},"c":{"2":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}},"docs":{}}}}},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}},".":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.017921146953405017},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0055248618784530384},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.012690355329949238},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.007035175879396985},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},"a":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.44040058622374206},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.008040201005025126}},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.013157894736842105}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"在":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"给":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"后":{"docs":{},"，":{"docs":{},"整":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"程":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"代":{"docs":{},"表":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"后":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"就":{"docs":{},"能":{"docs":{},"引":{"docs":{},"用":{"docs":{},"并":{"docs":{},"传":{"docs":{},"递":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"将":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.006060606060606061}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.024896265560165973}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"副":{"docs":{},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"并":{"docs":{},"把":{"docs":{},"每":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"和":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"非":{"docs":{},"完":{"docs":{},"全":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"超":{"docs":{},"类":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"0":{"docs":{},".":{"0":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"docs":{},"时":{"docs":{},"速":{"docs":{},"是":{"0":{"docs":{},"英":{"docs":{},"里":{"docs":{},"”":{"docs":{},"。":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"有":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"乘":{"docs":{},"客":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"数":{"docs":{},"量":{"docs":{},"设":{"docs":{},"为":{"5":{"docs":{},"，":{"docs":{},"轮":{"docs":{},"子":{"docs":{},"数":{"docs":{},"量":{"docs":{},"设":{"docs":{},"为":{"4":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}}}}}}}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"打":{"docs":{},"印":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}},"重":{"docs":{},"写":{"docs":{},"了":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"与":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"s":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.024676850763807285},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.03406998158379374},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.07167235494880546},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.011067193675889328},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.04065040650406504},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.017241379310344827},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":1.1364275668073136},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.014245014245014245},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"匹":{"docs":{},"配":{"docs":{},"同":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"，":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"点":{"docs":{},"(":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"前":{"docs":{},"跳":{"docs":{},"出":{"docs":{},"，":{"docs":{},"详":{"docs":{},"情":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}},"后":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"会":{"docs":{},"终":{"docs":{},"止":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"。":{"docs":{},"这":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"更":{"docs":{},"安":{"docs":{},"全":{"docs":{},"、":{"docs":{},"更":{"docs":{},"易":{"docs":{},"用":{"docs":{},"，":{"docs":{},"也":{"docs":{},"避":{"docs":{},"免":{"docs":{},"了":{"docs":{},"因":{"docs":{},"忘":{"docs":{},"记":{"docs":{},"写":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"在":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"余":{"docs":{},"下":{"docs":{},"所":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"五":{"docs":{},"个":{"docs":{},"元":{"docs":{},"音":{"docs":{},"，":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"允":{"docs":{},"许":{"docs":{},"将":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"值":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"临":{"docs":{},"时":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"在":{"docs":{},"该":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"包":{"docs":{},"含":{"docs":{},"至":{"docs":{},"少":{"docs":{},"一":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"像":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"样":{"docs":{},"书":{"docs":{},"写":{"docs":{},"代":{"docs":{},"码":{"docs":{},"是":{"docs":{},"无":{"docs":{},"效":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"用":{"docs":{},"于":{"docs":{},"简":{"docs":{},"化":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}},"快":{"docs":{},"没":{"docs":{},"有":{"docs":{},"实":{"docs":{},"际":{"docs":{},"的":{"docs":{},"意":{"docs":{},"义":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"剩":{"docs":{},"下":{"docs":{},"的":{"docs":{},"既":{"docs":{},"不":{"docs":{},"是":{"docs":{},"元":{"docs":{},"音":{"docs":{},"也":{"docs":{},"不":{"docs":{},"是":{"docs":{},"辅":{"docs":{},"音":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"就":{"docs":{},"保":{"docs":{},"证":{"docs":{},"了":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"常":{"docs":{},"量":{"docs":{},"x":{"docs":{},"和":{"docs":{},"y":{"docs":{},"的":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"临":{"docs":{},"时":{"docs":{},"获":{"docs":{},"取":{"docs":{},"元":{"docs":{},"组":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"—":{"docs":{},"—":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"常":{"docs":{},"量":{"docs":{},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"。":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"真":{"docs":{},"时":{"docs":{},"，":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"一":{"docs":{},"条":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"这":{"docs":{},"与":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{},"与":{"docs":{},"之":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}},"s":{"docs":{},"里":{"docs":{},"用":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}}}}},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":1.6840579710144925},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"层":{"docs":{},"次":{"docs":{},"作":{"docs":{},"为":{"docs":{},"例":{"docs":{},"子":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8333333333333333}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}},"'":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23396460929578386},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.28872936109117014}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}}},"u":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203}}},"属":{"docs":{},"性":{"docs":{},"之":{"docs":{},"后":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"1":{"5":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}},"x":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"'":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"一":{"docs":{},"个":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"原":{"docs":{},"点":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"自":{"docs":{},"动":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}},"c":{"docs":{},"k":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.013651877133105802},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8459815546772068},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}},"s":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"e":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":1.0519568151147098},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.006445672191528545},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.007032348804500703},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571}},"e":{"docs":{},"r":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503}}},"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}},"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"章":{"docs":{},"节":{"docs":{},"信":{"docs":{},"息":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"的":{"docs":{},"可":{"docs":{},"能":{"docs":{},"性":{"docs":{},"都":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"出":{"docs":{},"来":{"docs":{},"是":{"docs":{},"不":{"docs":{},"现":{"docs":{},"实":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"来":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"上":{"docs":{},"面":{"docs":{},"没":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"这":{"docs":{},"个":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"任":{"docs":{},"何":{"docs":{},"动":{"docs":{},"作":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"只":{"docs":{},"写":{"docs":{},"了":{"docs":{},"一":{"docs":{},"条":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"落":{"docs":{},"入":{"docs":{},"到":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"后":{"docs":{},"，":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"该":{"docs":{},"分":{"docs":{},"支":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"继":{"docs":{},"续":{"docs":{},"向":{"docs":{},"下":{"docs":{},",":{"docs":{},"开":{"docs":{},"始":{"docs":{},"执":{"docs":{},"行":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422}}}}}}}},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"是":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"即":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"的":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"）":{"docs":{},"\\":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}},"docs":{}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":5.003311258278146}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"以":{"docs":{},"请":{"docs":{},"求":{"docs":{},"和":{"docs":{},"调":{"docs":{},"用":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"方":{"docs":{},"法":{"docs":{},"及":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"性":{"docs":{},"体":{"docs":{},"现":{"docs":{},"于":{"docs":{},"请":{"docs":{},"求":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"当":{"docs":{},"前":{"docs":{},"可":{"docs":{},"能":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"有":{"docs":{},"值":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"调":{"docs":{},"用":{"docs":{},"就":{"docs":{},"会":{"docs":{},"成":{"docs":{},"功":{"docs":{},"；":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"选":{"docs":{},"择":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"种":{"docs":{},"调":{"docs":{},"用":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"多":{"docs":{},"次":{"docs":{},"请":{"docs":{},"求":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"链":{"docs":{},"接":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"形":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"链":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}},"r":{"docs":{},"i":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.010575793184488837},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.03734439834024896},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.020676691729323307},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.012853470437017995},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.022222222222222223},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8491436100131752},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.017543859649122806},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.011695906432748537},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.01306532663316583},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"前":{"docs":{},"添":{"docs":{},"加":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"（":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}},"）":{"docs":{},"来":{"docs":{},"将":{"docs":{},"整":{"docs":{},"个":{"docs":{},"类":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}},")":{"docs":{},"、":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},"这":{"docs":{},"些":{"docs":{},"目":{"docs":{},"标":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"访":{"docs":{},"问":{"docs":{},"对":{"docs":{},"象":{"docs":{},"、":{"docs":{},"集":{"docs":{},"合":{"docs":{},"或":{"docs":{},"序":{"docs":{},"列":{"docs":{},"的":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"方":{"docs":{},"式":{"docs":{},"。":{"docs":{},"举":{"docs":{},"例":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"用":{"docs":{},"下":{"docs":{},"标":{"docs":{},"访":{"docs":{},"问":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"=":{"docs":{},"\"":{"docs":{},"x":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"它":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{},"类":{"docs":{},"成":{"docs":{},"员":{"docs":{},";":{"docs":{},"用":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"或":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"实":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},",":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"为":{"docs":{},"类":{"docs":{},"成":{"docs":{},"员":{"docs":{},";":{"docs":{},"当":{"docs":{},"协":{"docs":{},"议":{"docs":{},"用":{"docs":{},"于":{"docs":{},"被":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"时":{"docs":{},",":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"、":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"、":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"、":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"、":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"、":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"、":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"u":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248}}}}},"u":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4375915974596971}}}}},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":1.3127747923790913},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.006030150753768844},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"需":{"docs":{},"要":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}},")":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"(":{"docs":{},"跟":{"docs":{},"方":{"docs":{},"法":{"docs":{},"主":{"docs":{},"体":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.006445672191528545},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.29174443646805454},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.05128205128205128}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"在":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"执":{"docs":{},"行":{"docs":{},"前":{"docs":{},"就":{"docs":{},"已":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"在":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"才":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007}}}}}}}}}},"n":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},"[":{"8":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.006445672191528545},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}},"o":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.017241379310344827}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767}}}}}},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0071146245059288534},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.02242152466367713}},"s":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"#":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"写":{"docs":{},"作":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}},"泛":{"docs":{},"型":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"指":{"docs":{},"定":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"其":{"docs":{},"里":{"docs":{},"面":{"docs":{},"的":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"保":{"docs":{},"证":{"docs":{},"只":{"docs":{},"有":{"docs":{},"正":{"docs":{},"确":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"可":{"docs":{},"以":{"docs":{},"加":{"docs":{},"进":{"docs":{},"容":{"docs":{},"器":{"docs":{},"里":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"明":{"docs":{},"确":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"其":{"docs":{},"下":{"docs":{},"标":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"指":{"docs":{},"定":{"docs":{},"容":{"docs":{},"器":{"docs":{},"里":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"将":{"docs":{},"会":{"docs":{},"保":{"docs":{},"留":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"知":{"docs":{},"道":{"docs":{},"特":{"docs":{},"定":{"docs":{},"容":{"docs":{},"器":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"需":{"docs":{},"要":{"docs":{},"指":{"docs":{},"定":{"docs":{},"任":{"docs":{},"何":{"docs":{},"通":{"docs":{},"过":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.007366482504604052},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.133903133903134},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"使":{"docs":{},"本":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"结":{"docs":{},"束":{"docs":{},"，":{"docs":{},"从":{"docs":{},"新":{"docs":{},"开":{"docs":{},"始":{"docs":{},"下":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"行":{"docs":{},"为":{"docs":{},"使":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"终":{"docs":{},"止":{"docs":{},"循":{"docs":{},"环":{"docs":{},"中":{"docs":{},"当":{"docs":{},"前":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"会":{"docs":{},"终":{"docs":{},"止":{"docs":{},"该":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"写":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"这":{"docs":{},"个":{"docs":{},"关":{"docs":{},"键":{"docs":{},"词":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"一":{"docs":{},"章":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.4375915974596971},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698}},"-":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.014245014245014245},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"<":{"docs":{},"/":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.023255813953488372},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.017994858611825194},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.02313624678663239},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"2":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"5":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198}}},"docs":{}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}}}}},"'":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.007712082262210797}}},"的":{"docs":{},"替":{"docs":{},"换":{"docs":{},"版":{"docs":{},"本":{"docs":{},"（":{"docs":{},"它":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"还":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"变":{"docs":{},"属":{"docs":{},"性":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}},"e":{"docs":{},"含":{"docs":{},"有":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"x":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"增":{"docs":{},"量":{"docs":{},"值":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"含":{"docs":{},"有":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"数":{"docs":{},"量":{"docs":{},"并":{"docs":{},"不":{"docs":{},"总":{"docs":{},"是":{"docs":{},"与":{"docs":{},"包":{"docs":{},"含":{"docs":{},"相":{"docs":{},"同":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}},"属":{"docs":{},"性":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"来":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"之":{"docs":{},"前":{"docs":{},"先":{"docs":{},"检":{"docs":{},"验":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"当":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"等":{"docs":{},"于":{"0":{"docs":{},"时":{"docs":{},"（":{"docs":{},"说":{"docs":{},"明":{"docs":{},"这":{"docs":{},"是":{"docs":{},"个":{"docs":{},"空":{"docs":{},"数":{"docs":{},"组":{"docs":{},"）":{"docs":{},"，":{"docs":{},"最":{"docs":{},"大":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"一":{"docs":{},"直":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"存":{"docs":{},"储":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"值":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"为":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"获":{"docs":{},"取":{"docs":{},"容":{"docs":{},"器":{"docs":{},"里":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"值":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01616161616161616},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"y":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}},"和":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"产":{"docs":{},"生":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"类":{"docs":{},"将":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"保":{"docs":{},"存":{"docs":{},"为":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"模":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"每":{"docs":{},"个":{"docs":{},"国":{"docs":{},"家":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"首":{"docs":{},"都":{"docs":{},"，":{"docs":{},"而":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"城":{"docs":{},"市":{"docs":{},"必":{"docs":{},"须":{"docs":{},"属":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"国":{"docs":{},"家":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"实":{"docs":{},"现":{"docs":{},"这":{"docs":{},"种":{"docs":{},"关":{"docs":{},"系":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"类":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"而":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"类":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"完":{"docs":{},"全":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"完":{"docs":{},"后":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"才":{"docs":{},"能":{"docs":{},"把":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"传":{"docs":{},"给":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"a":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.07142857142857142},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.013157894736842105},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"构":{"docs":{},"建":{"docs":{},"框":{"docs":{},"架":{"docs":{},"栈":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"标":{"docs":{},"准":{"docs":{},"化":{"docs":{},"。":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"的":{"docs":{},"n":{"docs":{},"s":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"函":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.014336917562724014},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.013651877133105802},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},">":{"docs":{},"$":{"0":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"、":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"$":{"1":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"、":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"$":{"2":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"。":{"docs":{},"反":{"docs":{},"引":{"docs":{},"号":{"docs":{},"不":{"docs":{},"属":{"docs":{},"于":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"`":{"docs":{},"x":{"docs":{},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.019943019943019943},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.011659807956104253}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.008960573476702509},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}},"u":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},">":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"用":{"docs":{},"于":{"docs":{},"替":{"docs":{},"代":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"等":{"docs":{},"等":{"docs":{},"）":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"及":{"docs":{},"其":{"docs":{},"关":{"docs":{},"联":{"docs":{},"约":{"docs":{},"束":{"docs":{},"提":{"docs":{},"供":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"约":{"docs":{},"束":{"docs":{},"。":{"docs":{},"如":{"docs":{},"，":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}},"s":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"不":{"docs":{},"是":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"得":{"docs":{},"等":{"docs":{},"于":{"0":{"docs":{},"，":{"1":{"docs":{},"，":{"2":{"docs":{},"和":{"3":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"在":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}}}}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}}}}}},"l":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":5.008908685968819},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":10.00507614213198},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{},"，":{"docs":{},"列":{"docs":{},"表":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},")":{"docs":{},"或":{"docs":{},"序":{"docs":{},"列":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.007366482504604052}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.12087912087912088}},"s":{"docs":{},"个":{"docs":{},"数":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"将":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"和":{"docs":{},"数":{"docs":{},"组":{"docs":{},"每":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"0":{"docs":{},".":{"0":{"docs":{},"，":{"docs":{},"都":{"docs":{},"传":{"docs":{},"入":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"正":{"docs":{},"确":{"docs":{},"大":{"docs":{},"小":{"docs":{},"的":{"docs":{},"新":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"析":{"docs":{},"构":{"docs":{},"方":{"docs":{},"法":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}},"p":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"e":{"docs":{},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}}}}}}}}},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"强":{"docs":{},"制":{"docs":{},"显":{"docs":{},"性":{"docs":{},"复":{"docs":{},"制":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"对":{"docs":{},"数":{"docs":{},"组":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"浅":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.07692307692307693}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.023668639053254437}}}}}},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.01775147928994083}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.009398496240601503},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198}},"值":{"docs":{},"大":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"之":{"docs":{},"前":{"docs":{},"任":{"docs":{},"意":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"新":{"docs":{},"值":{"docs":{},"保":{"docs":{},"存":{"docs":{},"在":{"docs":{},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"值":{"docs":{},"大":{"docs":{},"于":{"docs":{},"允":{"docs":{},"许":{"docs":{},"的":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"限":{"docs":{},"定":{"docs":{},"为":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"在":{"docs":{},"更":{"docs":{},"新":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"之":{"docs":{},"前":{"docs":{},"检":{"docs":{},"查":{"docs":{},"所":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"新":{"docs":{},"等":{"docs":{},"级":{"docs":{},"是":{"docs":{},"否":{"docs":{},"已":{"docs":{},"经":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"。":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"以":{"docs":{},"指":{"docs":{},"示":{"docs":{},"是":{"docs":{},"否":{"docs":{},"确":{"docs":{},"实":{"docs":{},"能":{"docs":{},"够":{"docs":{},"设":{"docs":{},"置":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843}},"e":{"docs":{},"逐":{"docs":{},"渐":{"docs":{},"接":{"docs":{},"近":{"docs":{},"到":{"0":{"docs":{},"是":{"docs":{},"需":{"docs":{},"要":{"docs":{},"向":{"docs":{},"正":{"docs":{},"数":{"docs":{},"走":{"docs":{},"还":{"docs":{},"是":{"docs":{},"向":{"docs":{},"负":{"docs":{},"数":{"docs":{},"走":{"docs":{},"。":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"是":{"3":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}}}}}}}}}}},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}},"t":{"docs":{},"i":{"docs":{},"z":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}},"b":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"三":{"docs":{},"维":{"docs":{},"空":{"docs":{},"间":{"docs":{},"的":{"docs":{},"立":{"docs":{},"方":{"docs":{},"体":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"、":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"只":{"docs":{},"读":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"用":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"立":{"docs":{},"方":{"docs":{},"体":{"docs":{},"的":{"docs":{},"体":{"docs":{},"积":{"docs":{},"，":{"docs":{},"设":{"docs":{},"置":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"毫":{"docs":{},"无":{"docs":{},"意":{"docs":{},"义":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"无":{"docs":{},"法":{"docs":{},"确":{"docs":{},"定":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"、":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01818181818181818},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3096891357760923}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}},"和":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"与":{"docs":{},"前":{"docs":{},"面":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"截":{"docs":{},"然":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"模":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"可":{"docs":{},"能":{"docs":{},"有":{"docs":{},"或":{"docs":{},"者":{"docs":{},"没":{"docs":{},"有":{"docs":{},"信":{"docs":{},"用":{"docs":{},"卡":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"一":{"docs":{},"张":{"docs":{},"信":{"docs":{},"用":{"docs":{},"卡":{"docs":{},"总":{"docs":{},"是":{"docs":{},"关":{"docs":{},"联":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"种":{"docs":{},"关":{"docs":{},"系":{"docs":{},"，":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"类":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"允":{"docs":{},"许":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"而":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"持":{"docs":{},"有":{"docs":{},"对":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"持":{"docs":{},"有":{"docs":{},"对":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"了":{"docs":{},"。":{"docs":{},"其":{"docs":{},"后":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"变":{"docs":{},"量":{"docs":{},"持":{"docs":{},"有":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"用":{"docs":{},"它":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"新":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"客":{"docs":{},"户":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}},"的":{"docs":{},"兼":{"docs":{},"容":{"docs":{},"性":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808}}}}}}}}}}}}}}},"语":{"docs":{},"言":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"默":{"docs":{},"认":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"数":{"docs":{},"值":{"docs":{},"运":{"docs":{},"算":{"docs":{},"中":{"docs":{},"出":{"docs":{},"现":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"但":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"更":{"docs":{},"加":{"docs":{},"清":{"docs":{},"晰":{"docs":{},"和":{"docs":{},"可":{"docs":{},"预":{"docs":{},"测":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"避":{"docs":{},"免":{"docs":{},"无":{"docs":{},"意":{"docs":{},"识":{"docs":{},"地":{"docs":{},"执":{"docs":{},"行":{"docs":{},"多":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"进":{"docs":{},"行":{"docs":{},"取":{"docs":{},"余":{"docs":{},"运":{"docs":{},"算":{"docs":{},"(":{"docs":{},"%":{"docs":{},")":{"docs":{},"，":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"没":{"docs":{},"有":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"两":{"docs":{},"数":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"区":{"docs":{},"间":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"(":{"docs":{},"a":{"docs":{},".":{"docs":{},".":{"docs":{},"b":{"docs":{},"和":{"docs":{},"a":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"指":{"docs":{},"针":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"并":{"docs":{},"不":{"docs":{},"直":{"docs":{},"接":{"docs":{},"指":{"docs":{},"向":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"也":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"星":{"docs":{},"号":{"docs":{},"(":{"docs":{},"*":{"docs":{},")":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"你":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"。":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"行":{"docs":{},"为":{"docs":{},"会":{"docs":{},"被":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"并":{"docs":{},"报":{"docs":{},"告":{"docs":{},"为":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"你":{"docs":{},"是":{"docs":{},"故":{"docs":{},"意":{"docs":{},"的":{"docs":{},"？":{"docs":{},"好":{"docs":{},"吧":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"为":{"docs":{},"你":{"docs":{},"准":{"docs":{},"备":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"套":{"docs":{},"默":{"docs":{},"认":{"docs":{},"允":{"docs":{},"许":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"如":{"docs":{},"可":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"加":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"+":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"允":{"docs":{},"许":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"都":{"docs":{},"是":{"docs":{},"以":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}},"风":{"docs":{},"格":{"docs":{},"的":{"docs":{},"落":{"docs":{},"入":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},")":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"每":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"该":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}}}}}}},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"确":{"docs":{},"已":{"docs":{},"改":{"docs":{},"为":{"docs":{},"了":{"2":{"0":{"4":{"8":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"docs":{},"之":{"docs":{},"前":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"h":{"docs":{},"d":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"其":{"docs":{},"实":{"docs":{},"是":{"docs":{},"h":{"docs":{},"d":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"副":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"h":{"docs":{},"d":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"h":{"docs":{},"d":{"docs":{},"和":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"有":{"docs":{},"着":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"宽":{"docs":{},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},"和":{"docs":{},"高":{"docs":{},"(":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00808080808080808}},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}},"y":{"docs":{},"!":{"docs":{},")":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"将":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"显":{"docs":{},"示":{"docs":{},"展":{"docs":{},"开":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"这":{"docs":{},"表":{"docs":{},"示":{"docs":{},"像":{"docs":{},"其":{"docs":{},"他":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"将":{"docs":{},"实":{"docs":{},"例":{"docs":{},"保":{"docs":{},"存":{"docs":{},"为":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}},",":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"基":{"docs":{},"类":{"docs":{},",":{"docs":{},"所":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"协":{"docs":{},"议":{"docs":{},",":{"docs":{},"前":{"docs":{},"者":{"docs":{},"把":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"写":{"docs":{},"为":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},",":{"docs":{},"后":{"docs":{},"者":{"docs":{},"则":{"docs":{},"把":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"c":{"docs":{},"+":{"docs":{},"+":{"docs":{},"或":{"docs":{},"者":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"的":{"docs":{},"经":{"docs":{},"验":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"你":{"docs":{},"也":{"docs":{},"许":{"docs":{},"会":{"docs":{},"知":{"docs":{},"道":{"docs":{},"这":{"docs":{},"些":{"docs":{},"语":{"docs":{},"言":{"docs":{},"使":{"docs":{},"用":{"docs":{},"指":{"docs":{},"针":{"docs":{},"来":{"docs":{},"引":{"docs":{},"用":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"的":{"docs":{},"地":{"docs":{},"址":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"方":{"docs":{},"便":{"docs":{},"对":{"docs":{},"变":{"docs":{},"量":{"docs":{},"本":{"docs":{},"身":{"docs":{},"加":{"1":{"docs":{},"或":{"docs":{},"减":{"1":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"比":{"docs":{},"较":{"docs":{},"运":{"docs":{},"算":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}},"-":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"c":{"6":{"6":{"9":{"9":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"s":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"等":{"docs":{},"效":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"从":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{},"而":{"docs":{},"来":{"docs":{},"的":{"docs":{},"新":{"docs":{},"协":{"docs":{},"议":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}},"?":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}}}}}}}}}}}}}}}}},"d":{"1":{"2":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}},"6":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}},"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}}},"v":{"docs":{},"e":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}}}}}}}},"t":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804}},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}},"e":{"docs":{},"r":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"不":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"当":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"没":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"更":{"docs":{},"有":{"docs":{},"意":{"docs":{},"义":{"docs":{},"的":{"docs":{},"是":{"docs":{},"当":{"docs":{},"用":{"docs":{},"到":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"导":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"该":{"docs":{},"功":{"docs":{},"能":{"docs":{},"由":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"没":{"docs":{},"有":{"docs":{},"写":{"docs":{},"出":{"docs":{},"全":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"能":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"后":{"docs":{},"边":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"?":{"docs":{},"标":{"docs":{},"记":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"只":{"docs":{},"在":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"非":{"docs":{},"空":{"docs":{},"时":{"docs":{},"才":{"docs":{},"去":{"docs":{},"调":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},",":{"docs":{},"但":{"docs":{},"是":{"docs":{},"也":{"docs":{},"无":{"docs":{},"法":{"docs":{},"保":{"docs":{},"证":{"docs":{},"其":{"docs":{},"是":{"docs":{},"否":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.008287292817679558},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23677754881758414},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0035252643948296123},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}},"-":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005483744614179397}},"i":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.011834319526627219},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01818181818181818},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"来":{"docs":{},"标":{"docs":{},"示":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.030303030303030304}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}},"b":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}}},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.015625},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0054869684499314125}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":10.018518518518519}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.004801097393689987}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"该":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"必":{"docs":{},"备":{"docs":{},"条":{"docs":{},"件":{"docs":{},",":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.01832460732984293}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"v":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"e":{"docs":{},"l":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}},"的":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"上":{"docs":{},"，":{"docs":{},"当":{"docs":{},"然":{"docs":{},"其":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"协":{"docs":{},"议":{"docs":{},"）":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"基":{"docs":{},"本":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"如":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}},",":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"特":{"docs":{},"化":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.008908685968819599},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}}}}}}}}},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.018796992481203006}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.022099447513812154},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.007518796992481203}},"l":{"docs":{},":":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}}}}}},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.010025062656641603}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"三":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"追":{"docs":{},"踪":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"过":{"docs":{},"程":{"docs":{},".":{"docs":{},"被":{"docs":{},"放":{"docs":{},"置":{"docs":{},"于":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"中":{"docs":{},",":{"docs":{},"即":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"任":{"docs":{},"意":{"docs":{},"含":{"docs":{},"有":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"的":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"实":{"docs":{},"现":{"docs":{},",":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"追":{"docs":{},"踪":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"含":{"docs":{},"有":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},",":{"docs":{},"前":{"docs":{},"者":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"有":{"docs":{},"几":{"docs":{},"个":{"docs":{},"面":{"docs":{},",":{"docs":{},"后":{"docs":{},"者":{"docs":{},"为":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},".":{"docs":{},"由":{"docs":{},"于":{"docs":{},"后":{"docs":{},"者":{"docs":{},"为":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},",":{"docs":{},"用":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"桌":{"docs":{},"游":{"docs":{},"中":{"docs":{},"的":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"被":{"docs":{},"当":{"docs":{},"作":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}},"遵":{"docs":{},"循":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"会":{"docs":{},"将":{"docs":{},"旧":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"命":{"docs":{},"名":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"的":{"docs":{},"值":{"docs":{},"改":{"docs":{},"变":{"docs":{},"后":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"它":{"docs":{},"把":{"docs":{},"新":{"docs":{},"的":{"docs":{},"值":{"docs":{},"和":{"docs":{},"旧":{"docs":{},"的":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"对":{"docs":{},"比":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"总":{"docs":{},"的":{"docs":{},"步":{"docs":{},"数":{"docs":{},"增":{"docs":{},"加":{"docs":{},"了":{"docs":{},"，":{"docs":{},"就":{"docs":{},"输":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"表":{"docs":{},"示":{"docs":{},"增":{"docs":{},"加":{"docs":{},"了":{"docs":{},"多":{"docs":{},"少":{"docs":{},"步":{"docs":{},"。":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.011235955056179775}},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.010276679841897233}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.017064846416382253}},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"当":{"docs":{},"它":{"docs":{},"等":{"docs":{},"于":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"打":{"docs":{},"印":{"docs":{},"“":{"docs":{},"l":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"推":{"docs":{},"断":{"docs":{},"当":{"docs":{},"它":{"docs":{},"被":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"更":{"docs":{},"短":{"docs":{},"的":{"docs":{},"点":{"docs":{},"（":{"docs":{},".":{"docs":{},"）":{"docs":{},"语":{"docs":{},"法":{"docs":{},"将":{"docs":{},"其":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.011067193675889328}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}},"o":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"o":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.012925969447708578},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.008960573476702509},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.012853470437017995},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.012648221343873518},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.017241379310344827},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.011278195488721804},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"添":{"docs":{},"加":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}},"精":{"docs":{},"确":{"docs":{},"度":{"docs":{},"很":{"docs":{},"高":{"docs":{},"，":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"1":{"5":{"docs":{},"位":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"而":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"最":{"docs":{},"少":{"docs":{},"只":{"docs":{},"有":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}},"表":{"docs":{},"示":{"6":{"4":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}},"docs":{}}},"[":{"docs":{},"]":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}},"和":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}},"型":{"docs":{},"的":{"docs":{},"值":{"1":{"docs":{},".":{"0":{"docs":{},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"1":{"docs":{},"米":{"docs":{},"”":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"为":{"docs":{},"什":{"docs":{},"么":{"docs":{},"m":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"—":{"docs":{},"—":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"1":{"docs":{},".":{"docs":{},"m":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"1":{"docs":{},".":{"0":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"docs":{}}},"docs":{},"看":{"docs":{},"作":{"docs":{},"是":{"docs":{},"某":{"docs":{},"单":{"docs":{},"位":{"docs":{},"下":{"docs":{},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"值":{"docs":{},"。":{"docs":{},"即":{"docs":{},"使":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},"为":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"一":{"docs":{},"个":{"docs":{},"带":{"docs":{},"有":{"docs":{},"d":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}},")":{"docs":{},"。":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"表":{"docs":{},"示":{"6":{"4":{"docs":{},"位":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"c":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}}}}}}}}}},"t":{"docs":{},"f":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"、":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.007366482504604052},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.1253561253561255},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}},"’":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"w":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.016600790513833993}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8333333333333333}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"(":{"docs":{},".":{"docs":{},")":{"docs":{},"语":{"docs":{},"法":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"在":{"docs":{},"其":{"docs":{},"它":{"docs":{},"模":{"docs":{},"块":{"docs":{},"（":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"或":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"内":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"引":{"docs":{},"用":{"docs":{},"在":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"模":{"docs":{},"块":{"docs":{},"中":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}},"’":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"`":{"docs":{},"`":{"docs":{},"o":{"docs":{},"`":{"docs":{},"`":{"docs":{},"g":{"docs":{},"`":{"docs":{},"`":{"docs":{},"!":{"docs":{},"和":{"docs":{},"":{"docs":{},"":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.013363028953229399}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.008908685968819599}},".":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"原":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"c":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.008928571428571428},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"-":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}},".":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.023890784982935155},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.017064846416382253},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}}}}}},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"数":{"docs":{},"组":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"。":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"语":{"docs":{},"法":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"（":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":3.333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}},"a":{"docs":{},"p":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}},"o":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.013089005235602094}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}},"。":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}},"表":{"docs":{},"示":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"t":{"docs":{},"的":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"t":{"docs":{},"有":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"在":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"保":{"docs":{},"证":{"docs":{},"支":{"docs":{},"持":{"docs":{},"等":{"docs":{},"式":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"说":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"事":{"docs":{},"实":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"“":{"docs":{},"任":{"docs":{},"何":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.5165799113167534},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.007833920877399139}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0039169604386995694}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}},"(":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"n":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.008695652173913044},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.008617312965139052}},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"l":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"l":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}},"，":{"docs":{},"那":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"基":{"docs":{},"数":{"docs":{},"和":{"1":{"0":{"docs":{},"^":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"docs":{}},"2":{"docs":{},"^":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.443209574987787},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":2.049246231155779},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.037037037037037035},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.019204389574759947}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"增":{"docs":{},"加":{"docs":{},"或":{"docs":{},"减":{"docs":{},"少":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"根":{"docs":{},"据":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"）":{"docs":{},"输":{"docs":{},"出":{"docs":{},"来":{"docs":{},"修":{"docs":{},"改":{"docs":{},"某":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"当":{"docs":{},"递":{"docs":{},"增":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"运":{"docs":{},"行":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"，":{"docs":{},"重":{"docs":{},"复":{"docs":{},"执":{"docs":{},"行":{"docs":{},"第":{"2":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.43478260869565216}}}}}},"前":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"型":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}},")":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"缀":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}},"强":{"docs":{},"制":{"docs":{},"取":{"docs":{},"值":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}}}},"显":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}},"超":{"docs":{},"类":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}},"闭":{"docs":{},"包":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}},"隐":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}},"。":{"docs":{},"起":{"docs":{},"保":{"docs":{},"护":{"docs":{},"作":{"docs":{},"用":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"构":{"docs":{},"成":{"docs":{},"的":{"docs":{},"：":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"作":{"docs":{},"为":{"docs":{},"额":{"docs":{},"外":{"docs":{},"测":{"docs":{},"试":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"且":{"docs":{},"起":{"docs":{},"保":{"docs":{},"护":{"docs":{},"作":{"docs":{},"用":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"真":{"docs":{},"时":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"只":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"相":{"docs":{},"等":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"，":{"docs":{},"如":{"docs":{},"(":{"1":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"首":{"docs":{},"先":{"docs":{},"被":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"与":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"将":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"都":{"docs":{},"不":{"docs":{},"能":{"docs":{},"为":{"docs":{},"空":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"在":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"docs":{},"一":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"不":{"docs":{},"想":{"docs":{},"在":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"在":{"docs":{},"块":{"docs":{},"里":{"docs":{},"写":{"docs":{},"一":{"docs":{},"条":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}},":":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":10.031609195402298},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"[":{"6":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"7":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23677754881758414},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.8747066055661116},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"r":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.014245014245014245}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"w":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875}}}},"g":{"docs":{},"g":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0200445434298441}},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.013651877133105802}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}}},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"c":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.008695652173913044},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.015228426395939087},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"语":{"docs":{},"句":{"docs":{},"也":{"docs":{},"可":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}},"，":{"docs":{},"当":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}},"l":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698}},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"类":{"docs":{},"循":{"docs":{},"环":{"docs":{},"适":{"docs":{},"合":{"docs":{},"使":{"docs":{},"用":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"前":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"次":{"docs":{},"数":{"docs":{},"未":{"docs":{},"知":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"是":{"docs":{},"知":{"docs":{},"道":{"docs":{},"紧":{"docs":{},"急":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"重":{"docs":{},"置":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"整":{"docs":{},"个":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"还":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"事":{"docs":{},"实":{"docs":{},"上":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.113960113960114}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.1196581196581197},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"不":{"docs":{},"会":{"docs":{},"检":{"docs":{},"查":{"docs":{},"它":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"将":{"docs":{},"会":{"docs":{},"落":{"docs":{},"入":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"条":{"docs":{},"件":{"docs":{},"。":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"使":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"继":{"docs":{},"续":{"docs":{},"连":{"docs":{},"接":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"这":{"docs":{},"和":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"标":{"docs":{},"准":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"语":{"docs":{},"句":{"docs":{},"可":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"里":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"能":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"传":{"docs":{},"递":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"。":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"从":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"传":{"docs":{},"递":{"docs":{},"是":{"docs":{},"无":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"与":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{}}}}}}}},"的":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"，":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"采":{"docs":{},"用":{"docs":{},"了":{"docs":{},"很":{"docs":{},"多":{"docs":{},"传":{"docs":{},"统":{"docs":{},"上":{"docs":{},"只":{"docs":{},"被":{"docs":{},"类":{"docs":{},"所":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"特":{"docs":{},"征":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"s":{"docs":{},"和":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"都":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"1":{"docs":{},"跟":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"按":{"docs":{},"位":{"docs":{},"异":{"docs":{},"或":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"把":{"docs":{},"它":{"docs":{},"这":{"docs":{},"些":{"docs":{},"位":{"docs":{},"置":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"都":{"docs":{},"置":{"docs":{},"为":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"s":{"docs":{},"和":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"中":{"docs":{},"间":{"4":{"docs":{},"个":{"docs":{},"位":{"docs":{},"都":{"docs":{},"为":{"1":{"docs":{},"。":{"docs":{},"对":{"docs":{},"它":{"docs":{},"俩":{"docs":{},"进":{"docs":{},"行":{"docs":{},"按":{"docs":{},"位":{"docs":{},"与":{"docs":{},"运":{"docs":{},"算":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"得":{"docs":{},"到":{"docs":{},"了":{"0":{"0":{"1":{"1":{"1":{"1":{"0":{"0":{"docs":{},"，":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"6":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.012448132780082987},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"下":{"docs":{},"标":{"docs":{},"，":{"docs":{},"在":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"。":{"docs":{},"在":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"中":{"docs":{},"，":{"docs":{},"你":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"类":{"docs":{},"里":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"下":{"docs":{},"标":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"里":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"防":{"docs":{},"止":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"重":{"docs":{},"写":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.011970534069981584},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.007518796992481203}},"e":{"docs":{},",":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},",":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"表":{"docs":{},"明":{"docs":{},"你":{"docs":{},"必":{"docs":{},"须":{"docs":{},"刚":{"docs":{},"好":{"docs":{},"落":{"docs":{},"在":{"docs":{},"方":{"docs":{},"格":{"2":{"5":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"，":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"，":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"[":{"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},">":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}},"中":{"docs":{},"这":{"docs":{},"个":{"docs":{},"单":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"写":{"docs":{},"做":{"docs":{},"：":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"现":{"docs":{},"在":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"成":{"docs":{},"功":{"docs":{},"的":{"docs":{},"编":{"docs":{},"译":{"docs":{},"过":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"如":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"或":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"去":{"docs":{},"查":{"docs":{},"找":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"给":{"docs":{},"定":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"若":{"docs":{},"查":{"docs":{},"找":{"docs":{},"到":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"该":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"在":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"反":{"docs":{},"之":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}},")":{"docs":{},"，":{"docs":{},"它":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"是":{"docs":{},"当":{"docs":{},"前":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"(":{"2":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"并":{"docs":{},"指":{"docs":{},"定":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"4":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}},"docs":{}}}}}}}},"表":{"docs":{},"示":{"3":{"2":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}},"docs":{}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571}},"-":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"p":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}},"w":{"docs":{},"章":{"docs":{},"节":{"docs":{},"有":{"docs":{},"该":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"详":{"docs":{},"细":{"docs":{},"介":{"docs":{},"绍":{"docs":{},")":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"新":{"docs":{},"版":{"docs":{},"本":{"docs":{},".":{"docs":{},"新":{"docs":{},"版":{"docs":{},"本":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"作":{"docs":{},"为":{"docs":{},"骰":{"docs":{},"子":{"docs":{},",":{"docs":{},"并":{"docs":{},"且":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.007366482504604052},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.1196581196581197},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"循":{"docs":{},"环":{"docs":{},"来":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"某":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"的":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"都":{"docs":{},"由":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}},"和":{"docs":{},"半":{"docs":{},"闭":{"docs":{},"区":{"docs":{},"间":{"docs":{},"操":{"docs":{},"作":{"docs":{},"(":{"docs":{},".":{"docs":{},".":{"docs":{},")":{"docs":{},"来":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"每":{"docs":{},"个":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"不":{"docs":{},"等":{"docs":{},"于":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"不":{"docs":{},"等":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"条":{"docs":{},"件":{"docs":{},"递":{"docs":{},"增":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.6666666666666665}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"或":{"docs":{},"常":{"docs":{},"量":{"docs":{},"申":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"或":{"docs":{},"者":{"docs":{},"其":{"docs":{},"他":{"docs":{},"包":{"docs":{},"含":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"是":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"重":{"docs":{},"复":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"集":{"docs":{},"合":{"docs":{},"(":{"docs":{},"或":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"前":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"）":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"回":{"docs":{},"到":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"处":{"docs":{},"；":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.011396011396011397},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}}},"条":{"docs":{},"件":{"docs":{},"递":{"docs":{},"增":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474}},"e":{"docs":{},"-":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}}}}},"d":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.008695652173913044},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"—":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}},"语":{"docs":{},"句":{"docs":{},"、":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"语":{"docs":{},"句":{"docs":{},"、":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"还":{"docs":{},"是":{"docs":{},"会":{"docs":{},"被":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"每":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"b":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.008960573476702509},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"a":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},";":{"docs":{},")":{"docs":{},"元":{"docs":{},"组":{"docs":{},"把":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.010752688172043012}},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"从":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"改":{"docs":{},"为":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"!":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"试":{"docs":{},"图":{"docs":{},"找":{"docs":{},"到":{"docs":{},"具":{"docs":{},"有":{"docs":{},"特":{"docs":{},"定":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"通":{"docs":{},"过":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"7":{"docs":{},"识":{"docs":{},"别":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.007614213197969543}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0282021151586369},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.03938115330520394},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.014044943820224719},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.04113110539845758},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.01775147928994083},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.009933774834437087},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.02882205513784461},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.03288490284005979},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.004308656482569526},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.02046783625730994},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"-":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.49043273476597},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.883610161211529},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.01046337817638266},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.006658832745789268},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.29978463747307965}},"s":{"docs":{},"）":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"与":{"docs":{},"调":{"docs":{},"用":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"定":{"docs":{},"义":{"docs":{},"在":{"docs":{},"全":{"docs":{},"局":{"docs":{},"域":{"docs":{},"中":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"把":{"docs":{},"函":{"docs":{},"数":{"docs":{},"定":{"docs":{},"义":{"docs":{},"在":{"docs":{},"别":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"称":{"docs":{},"作":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"函":{"docs":{},"数":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"包":{"docs":{},"括":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"权":{"docs":{},"限":{"docs":{},"获":{"docs":{},"取":{"docs":{},"原":{"docs":{},"始":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"能":{"docs":{},"力":{"docs":{},"（":{"docs":{},"即":{"docs":{},"逆":{"docs":{},"向":{"docs":{},"建":{"docs":{},"模":{"docs":{},"）":{"docs":{},"。":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"分":{"docs":{},"类":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{},"（":{"docs":{},"不":{"docs":{},"过":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}},"）":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"柯":{"docs":{},"里":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"(":{"docs":{},")":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"中":{"docs":{},"，":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"。":{"docs":{},"指":{"docs":{},"定":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"用":{"docs":{},"返":{"docs":{},"回":{"docs":{},"箭":{"docs":{},"头":{"docs":{},"-":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"之":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"；":{"docs":{},"声":{"docs":{},"明":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"之":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"e":{"docs":{},"d":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},".":{"docs":{},"因":{"docs":{},"此":{"docs":{},"其":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"者":{"docs":{},"必":{"docs":{},"须":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"e":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"）":{"docs":{},"\\":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"a":{"docs":{},"）":{"docs":{},"、":{"docs":{},"回":{"docs":{},"车":{"docs":{},"符":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}},"c":{"docs":{},"）":{"docs":{},"以":{"docs":{},"及":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"）":{"docs":{},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"e":{"docs":{},"t":{"docs":{},"g":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}},"s":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992}}}}}}},"（":{"docs":{},"或":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.16666666666666666},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.125}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.125},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"​":{"docs":{},"​":{"docs":{},"块":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"后":{"docs":{},"跟":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"构":{"docs":{},"成":{"docs":{},"，":{"docs":{},"用":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"后":{"docs":{},"跟":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.041666666666666664}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}},"获":{"docs":{},"取":{"docs":{},"某":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"但":{"docs":{},"它":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"写":{"docs":{},"在":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"接":{"docs":{},"受":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.007518796992481203},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.06201550387596899},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}},"e":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"]":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.031007751937984496},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.006172839506172839}}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}},"b":{"docs":{},"y":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414}}}}}},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"结":{"docs":{},"束":{"docs":{},"它":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}},"t":{"docs":{},"m":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"n":{"docs":{},"k":{"docs":{},"l":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}},"a":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"p":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"e":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.08333333333333333},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.042735042735042736}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.016483516483516484}},"[":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.012658227848101266},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.02247191011235955},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.10989010989010989},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.02631578947368421},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.004801097393689987}},";":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}},"g":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}},"！":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.023668639053254437},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.015037593984962405}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"去":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"严":{"docs":{},"格":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"影":{"docs":{},"响":{"docs":{},"到":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"歧":{"docs":{},"义":{"docs":{},"的":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"也":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"危":{"docs":{},"害":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"符":{"docs":{},"合":{"docs":{},"标":{"docs":{},"签":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"规":{"docs":{},"则":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"参":{"docs":{},"照":{"docs":{},"旁":{"docs":{},"边":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"结":{"docs":{},"束":{"docs":{},"本":{"docs":{},"次":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}},"跳":{"docs":{},"转":{"docs":{},"控":{"docs":{},"制":{"docs":{},"去":{"docs":{},"执":{"docs":{},"行":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}},",":{"docs":{},"d":{"1":{"2":{"docs":{},",":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}},"方":{"docs":{},"法":{"docs":{},"从":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"参":{"docs":{},"数":{"docs":{},"获":{"docs":{},"取":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"信":{"docs":{},"息":{"docs":{},"并":{"docs":{},"输":{"docs":{},"出":{"docs":{},".":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"被":{"docs":{},"当":{"docs":{},"做":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},",":{"docs":{},"所":{"docs":{},"以":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"只":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0035252643948296123}},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"u":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"，":{"docs":{},"即":{"docs":{},"便":{"docs":{},"你":{"docs":{},"没":{"docs":{},"有":{"docs":{},"实":{"docs":{},"现":{"docs":{},"它":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"是":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"集":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"于":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"任":{"docs":{},"何":{"docs":{},"其":{"docs":{},"他":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"数":{"docs":{},"据":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"存":{"docs":{},"储":{"docs":{},"任":{"docs":{},"何":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},",":{"docs":{},"通":{"docs":{},"过":{"docs":{},"a":{"docs":{},"s":{"docs":{},"?":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"将":{"docs":{},"其":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},"/":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676}}}}},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},"e":{"docs":{},"和":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"产":{"docs":{},"生":{"docs":{},"的":{"docs":{},"。":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"它":{"docs":{},"所":{"docs":{},"替":{"docs":{},"代":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"约":{"docs":{},"束":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"任":{"docs":{},"何":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"所":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"要":{"docs":{},"求":{"docs":{},"满":{"docs":{},"足":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"也":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676}}},"y":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"但":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"值":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"f":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}},"v":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}},"r":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351}}}}}}}},"w":{"docs":{},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"e":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"成":{"docs":{},"员":{"docs":{},"：":{"docs":{},"给":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"常":{"docs":{},"量":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"全":{"docs":{},"名":{"docs":{},"来":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"没":{"docs":{},"有":{"docs":{},"显":{"docs":{},"式":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"里":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"使":{"docs":{},"用":{"docs":{},"缩":{"docs":{},"写":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"来":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"的":{"docs":{},"值":{"docs":{},"已":{"docs":{},"经":{"docs":{},"知":{"docs":{},"道":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.007518796992481203},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.02531645569620253},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.007853403141361256},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.011494252873563218},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"-":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}},"p":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}}},"r":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.008298755186721992},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.009398496240601503},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"’":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655}}},"'":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"x":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.03794642857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.011659807956104253}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.009398496240601503},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.008620689655172414}},"=":{"docs":{},"\"":{"1":{"2":{"0":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"docs":{}},"6":{"9":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"docs":{}},"docs":{}},"2":{"8":{"8":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}},"docs":{}},"9":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"docs":{}},"docs":{}},"3":{"5":{"7":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}},"8":{"7":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"docs":{}},"docs":{}},"docs":{}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}}}}}},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}},"l":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"0":{"0":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"4":{"0":{"4":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007}},".":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"1":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}}}},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.012121212121212121}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"别":{"docs":{},"打":{"docs":{},"印":{"docs":{},"，":{"docs":{},"证":{"docs":{},"明":{"docs":{},"了":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"解":{"docs":{},"决":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"这":{"docs":{},"样":{"docs":{},"编":{"docs":{},"写":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"和":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"在":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"多":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"占":{"docs":{},"有":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"，":{"docs":{},"占":{"docs":{},"有":{"docs":{},"列":{"docs":{},"表":{"docs":{},"是":{"docs":{},"[":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"产":{"docs":{},"生":{"docs":{},"了":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}},"只":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"的":{"docs":{},"话":{"docs":{},")":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"该":{"docs":{},"类":{"docs":{},"也":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"当":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"代":{"docs":{},"表":{"docs":{},"段":{"docs":{},"落":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"代":{"docs":{},"表":{"docs":{},"换":{"docs":{},"行":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"r":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"。":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"设":{"docs":{},"置":{"docs":{},"和":{"docs":{},"展":{"docs":{},"现":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"，":{"docs":{},"将":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"组":{"docs":{},"合":{"docs":{},"成":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.010282776349614395}}}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"-":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.8372859025032937},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"还":{"docs":{},"是":{"1":{"9":{"2":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"全":{"docs":{},"高":{"docs":{},"清":{"docs":{},"视":{"docs":{},"频":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"(":{"1":{"9":{"2":{"0":{"docs":{},"像":{"docs":{},"素":{"docs":{},"宽":{"docs":{},"，":{"1":{"0":{"8":{"0":{"docs":{},"像":{"docs":{},"素":{"docs":{},"高":{"docs":{},")":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"予":{"docs":{},"给":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"将":{"docs":{},"h":{"docs":{},"d":{"docs":{},"中":{"docs":{},"所":{"docs":{},"储":{"docs":{},"存":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"储":{"docs":{},"存":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"。":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"两":{"docs":{},"个":{"docs":{},"完":{"docs":{},"全":{"docs":{},"独":{"docs":{},"立":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"碰":{"docs":{},"巧":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"两":{"docs":{},"者":{"docs":{},"相":{"docs":{},"互":{"docs":{},"独":{"docs":{},"立":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"将":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"2":{"0":{"4":{"8":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"影":{"docs":{},"响":{"docs":{},"h":{"docs":{},"d":{"docs":{},"中":{"docs":{},"的":{"docs":{},"宽":{"docs":{},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.04040404040404041},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"!":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"设":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"后":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}},",":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"被":{"docs":{},"设":{"docs":{},"定":{"docs":{},"为":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"都":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"后":{"docs":{},"，":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"现":{"docs":{},"在":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"变":{"docs":{},"量":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"客":{"docs":{},"户":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"里":{"docs":{},"的":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"两":{"docs":{},"层":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"来":{"docs":{},"联":{"docs":{},"系":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"和":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"!":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"?":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.009933774834437087}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}},"[":{"0":{"docs":{},"]":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}}}}}}}},"docs":{}}},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"运":{"docs":{},"行":{"docs":{},"通":{"docs":{},"过":{"docs":{},"，":{"docs":{},"且":{"docs":{},"会":{"docs":{},"将":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"现":{"docs":{},"在":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"现":{"docs":{},"在":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"面":{"docs":{},"，":{"docs":{},"在":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"括":{"docs":{},"号":{"docs":{},"的":{"docs":{},"前":{"docs":{},"面":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.013245033112582781}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.011834319526627219}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}},"s":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}},"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.007032348804500703}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.014064697609001406}},"的":{"docs":{},"值":{"docs":{},"没":{"docs":{},"有":{"docs":{},"被":{"docs":{},"指":{"docs":{},"定":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"（":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"和":{"docs":{},"s":{"1":{"docs":{},"的":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"，":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"和":{"docs":{},"s":{"2":{"docs":{},"的":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"，":{"docs":{},"第":{"docs":{},"三":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"和":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"提":{"docs":{},"供":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"t":{"docs":{},"y":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}},"n":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}},"e":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.008908685968819599},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0056179775280898875},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}},"y":{"docs":{},"s":{"docs":{},"或":{"docs":{},"者":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}}}}},")":{"docs":{},"和":{"docs":{},"/":{"docs":{},"或":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"是":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"或":{"docs":{},"枚":{"docs":{},"举":{"docs":{},")":{"docs":{},"，":{"docs":{},"当":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"键":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},")":{"docs":{},"和":{"docs":{},"/":{"docs":{},"或":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"是":{"docs":{},"整":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"e":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.014367816091954023}}},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}},"o":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}},"s":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}}}}}},"u":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"k":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.008426966292134831}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.008426966292134831}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"初":{"docs":{},"始":{"docs":{},"为":{"0":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"其":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},"s":{"docs":{},"或":{"docs":{},"者":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"数":{"docs":{},"字":{"1":{"0":{"docs":{},"或":{"docs":{},"者":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"给":{"docs":{},"它":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"1":{"0":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"并":{"docs":{},"将":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"所":{"docs":{},"有":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.011278195488721804}}}}}},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}},"p":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.014044943820224719}},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"2":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}},"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"‘":{"docs":{},"一":{"docs":{},"个":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"’":{"docs":{},"，":{"docs":{},"并":{"docs":{},"让":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.016483516483516484}},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}},"[":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"2":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"docs":{}},"下":{"docs":{},"标":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"同":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"下":{"docs":{},"标":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"判":{"docs":{},"断":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"方":{"docs":{},"便":{"docs":{},"进":{"docs":{},"行":{"docs":{},"断":{"docs":{},"言":{"docs":{},"，":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"确":{"docs":{},"认":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"或":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"阅":{"docs":{},"读":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"从":{"docs":{},"左":{"docs":{},"上":{"docs":{},"到":{"docs":{},"右":{"docs":{},"下":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"实":{"docs":{},"例":{"docs":{},"g":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"两":{"docs":{},"个":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"入":{"docs":{},"参":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"s":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"足":{"docs":{},"够":{"docs":{},"容":{"docs":{},"纳":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"右":{"docs":{},"上":{"docs":{},"值":{"docs":{},"为":{"1":{"docs":{},".":{"5":{"docs":{},"，":{"docs":{},"坐":{"docs":{},"下":{"docs":{},"值":{"docs":{},"为":{"3":{"docs":{},".":{"2":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"docs":{}}},"docs":{}}}}}}},"docs":{}}},"docs":{}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"将":{"docs":{},"呈":{"docs":{},"现":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"二":{"docs":{},"维":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"）":{"docs":{},"”":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"“":{"docs":{},"最":{"docs":{},"大":{"docs":{},"适":{"docs":{},"合":{"docs":{},"”":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}}},"k":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"d":{"docs":{},"e":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}},"s":{"docs":{},"k":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.46048954956968813},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}},"）":{"docs":{},"，":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}},"类":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"提":{"docs":{},"供":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"所":{"docs":{},"代":{"docs":{},"表":{"docs":{},"的":{"docs":{},"值":{"docs":{},"相":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"；":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"；":{"docs":{},"可":{"docs":{},"以":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}}},")":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}},"。":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"类":{"docs":{},"、":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"修":{"docs":{},"改":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"变":{"docs":{},"异":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"和":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"用":{"docs":{},"来":{"docs":{},"移":{"docs":{},"动":{"docs":{},"一":{"docs":{},"个":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"修":{"docs":{},"改":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"方":{"docs":{},"法":{"docs":{},"定":{"docs":{},"义":{"docs":{},"时":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.43478260869565216}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"当":{"docs":{},"前":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.017241379310344827}}}},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.004700352526439483}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.010752688172043012},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.5804737975592247}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}},")":{"docs":{},"中":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"这":{"docs":{},"个":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"顶":{"docs":{},"端":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}}}}}},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.020553359683794466}},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"能":{"docs":{},"够":{"docs":{},"使":{"docs":{},"用":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"不":{"docs":{},"确":{"docs":{},"定":{"docs":{},"，":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.45020677322007374},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.016442451420029897},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"方":{"docs":{},"法":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"方":{"docs":{},"法":{"docs":{},"内":{"docs":{},"部":{"docs":{},"改":{"docs":{},"变":{"docs":{},"它":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"；":{"docs":{},"并":{"docs":{},"且":{"docs":{},"它":{"docs":{},"做":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"改":{"docs":{},"变":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"都":{"docs":{},"会":{"docs":{},"回":{"docs":{},"写":{"docs":{},"到":{"docs":{},"原":{"docs":{},"始":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"方":{"docs":{},"法":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"给":{"docs":{},"它":{"docs":{},"隐":{"docs":{},"含":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},",":{"docs":{},"不":{"docs":{},"用":{"docs":{},"写":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},";":{"docs":{},"用":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},",":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"实":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},",":{"docs":{},"必":{"docs":{},"须":{"docs":{},"写":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}},"g":{"docs":{},"u":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}},"p":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.235371079056684},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.007518796992481203},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"e":{"docs":{},"r":{"docs":{},"作":{"docs":{},"为":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}},"s":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}},"c":{"docs":{},"h":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.008040201005025126}}}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.007853403141361256}}}}}}}}},"l":{"docs":{},"k":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.008908685968819599}},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}}},"x":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"d":{"docs":{},"d":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}},"p":{"docs":{},"h":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.016597510373443983}}}},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"r":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}},"e":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"v":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.006445672191528545},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0027418723070896985}},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563}},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}}}}}}}}},"指":{"docs":{},"向":{"docs":{},"了":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"数":{"docs":{},"到":{"0":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"(":{"docs":{},"它":{"docs":{},"的":{"docs":{},"x":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.05928853754940711}},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474}}}}}},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695}}}}}}},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"三":{"docs":{},"个":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"在":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"时":{"docs":{},"根":{"docs":{},"据":{"docs":{},"它":{"docs":{},"的":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"标":{"docs":{},"记":{"docs":{},"符":{"docs":{},"和":{"docs":{},"里":{"docs":{},"面":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"（":{"docs":{},"p":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"用":{"docs":{},"于":{"docs":{},"打":{"docs":{},"印":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"它":{"docs":{},"的":{"docs":{},"导":{"docs":{},"演":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"。":{"docs":{},"当":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"真":{"docs":{},"的":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"（":{"docs":{},"这":{"docs":{},"个":{"docs":{},"是":{"docs":{},"为":{"docs":{},"了":{"docs":{},"判":{"docs":{},"断":{"docs":{},"下":{"docs":{},"转":{"docs":{},"是":{"docs":{},"否":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{},"）":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"写":{"docs":{},"的":{"docs":{},"“":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}},"d":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},")":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"h":{"docs":{},"d":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"(":{"1":{"9":{"2":{"0":{"docs":{},"*":{"1":{"0":{"8":{"0":{"docs":{},")":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"(":{"docs":{},"h":{"docs":{},"d":{"docs":{},")":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"交":{"docs":{},"错":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"“":{"1":{"0":{"8":{"0":{"docs":{},"i":{"docs":{},"”":{"docs":{},"。":{"docs":{},"最":{"docs":{},"后":{"docs":{},"，":{"docs":{},"其":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"是":{"2":{"5":{"docs":{},".":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"y":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"u":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422}},"e":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"只":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.005875440658049354},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.022326674500587545},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.015590200445434299},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.24099695810028457},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.44040058622374206},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.8772772996535151},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.013089005235602094},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.03232323232323232},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.03642384105960265},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.008695652173913044},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.015037593984962405},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.007035175879396985},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.011396011396011397}},"d":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123}},"e":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"接":{"docs":{},"收":{"docs":{},"两":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"半":{"docs":{},"径":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"包":{"docs":{},"含":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},";":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"协":{"docs":{},"议":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"=":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"_":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}},"docs":{}},"8":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":5.007751937984496}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},">":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"1":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"2":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"3":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"4":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"5":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"6":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"7":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"8":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}},"docs":{}}}}},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"[":{"1":{"6":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}},"docs":{}},"docs":{}}}}}}}}}}}},"）":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}},"简":{"docs":{},"写":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}},"数":{"docs":{},"组":{"docs":{},"确":{"docs":{},"已":{"docs":{},"被":{"docs":{},"复":{"docs":{},"制":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"将":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"从":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},",":{"docs":{},"则":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"仍":{"docs":{},"是":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"发":{"docs":{},"生":{"docs":{},"前":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"七":{"docs":{},"个":{"docs":{},"人":{"docs":{},"名":{"docs":{},"。":{"docs":{},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"用":{"docs":{},"以":{"docs":{},"储":{"docs":{},"存":{"docs":{},"在":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"上":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}},"(":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.008287292817679558}}}}}}}}}}},"i":{"docs":{},"v":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}}}},"e":{"docs":{},"w":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.011834319526627219},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0035252643948296123},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}}},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"相":{"docs":{},"同":{"docs":{},"。":{"docs":{},"与":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"入":{"docs":{},"参":{"docs":{},"声":{"docs":{},"明":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"就":{"docs":{},"算":{"docs":{},"不":{"docs":{},"写":{"docs":{},"，":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}},"x":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"开":{"docs":{},"关":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"电":{"docs":{},"源":{"docs":{},"状":{"docs":{},"态":{"docs":{},"(":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},",":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}},"e":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005483744614179397}}},"a":{"docs":{},"r":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.016877637130801686}}}}},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":5.021505376344086},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.024242424242424242},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.014619883040935672},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.007035175879396985}},"，":{"docs":{},"?":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"件":{"docs":{},"会":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"被":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"会":{"docs":{},"将":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}},"但":{"docs":{},"是":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"运":{"docs":{},"行":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"是":{"docs":{},"指":{"docs":{},"针":{"docs":{},"—":{"docs":{},"—":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"确":{"docs":{},"定":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"值":{"docs":{},"缺":{"docs":{},"失":{"docs":{},"。":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"请":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"解":{"docs":{},"析":{"docs":{},"可":{"docs":{},"选":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"中":{"docs":{},"判":{"docs":{},"断":{"docs":{},"是":{"docs":{},"否":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"使":{"docs":{},"用":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"后":{"docs":{},"再":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"式":{"docs":{},"断":{"docs":{},"开":{"docs":{},"两":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"(":{"docs":{},"包":{"docs":{},"括":{"docs":{},"最":{"docs":{},"先":{"docs":{},"的":{"docs":{},"那":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"）":{"docs":{},"，":{"docs":{},"只":{"docs":{},"留":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"项":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"运":{"docs":{},"行":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"内":{"docs":{},"的":{"docs":{},"占":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"总":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"当":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"后":{"docs":{},"，":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"值":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"循":{"docs":{},"环":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"了":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"和":{"docs":{},"前":{"docs":{},"面":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"来":{"docs":{},"获":{"docs":{},"得":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"1":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"不":{"docs":{},"论":{"docs":{},"你":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"方":{"docs":{},"法":{"docs":{},"、":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"等":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"不":{"docs":{},"是":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"值":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"都":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"值":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"利":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"来":{"docs":{},"检":{"docs":{},"测":{"docs":{},"你":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"是":{"docs":{},"否":{"docs":{},"调":{"docs":{},"用":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"即":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}},"-":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.02030456852791878},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.028277634961439587},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.047337278106508875},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.013452914798206279},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"”":{"docs":{},"。":{"docs":{},"当":{"docs":{},"它":{"docs":{},"等":{"docs":{},"于":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"打":{"docs":{},"印":{"docs":{},"“":{"docs":{},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"成":{"docs":{},"员":{"docs":{},"）":{"docs":{},"。":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.04395604395604396}},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"(":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},"为":{"docs":{},"用":{"docs":{},"该":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"经":{"docs":{},"用":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"你":{"docs":{},"则":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"为":{"docs":{},"没":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"。":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"规":{"docs":{},"则":{"docs":{},"试":{"docs":{},"用":{"docs":{},"于":{"docs":{},"当":{"docs":{},"你":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.005979073243647235},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}},"a":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01616161616161616}},"!":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}}},"docs":{}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.01645123384253819},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.007032348804500703},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.028089887640449437},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.01818181818181818},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.033112582781456956},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.018409714061887975},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.007050528789659225}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.015424164524421594}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"0":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}},"docs":{}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498}}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"并":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"出":{"docs":{},"了":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"对":{"docs":{},"键":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"存":{"docs":{},"放":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"为":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.023668639053254437}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.019867549668874173}},"s":{"docs":{},"是":{"docs":{},"非":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"？":{"docs":{},"）":{"docs":{},"时":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"也":{"docs":{},"成":{"docs":{},"立":{"docs":{},"。":{"docs":{},"只":{"docs":{},"要":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"最":{"docs":{},"后":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"总":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"？":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"？":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"称":{"docs":{},"作":{"docs":{},"“":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"”":{"docs":{},"。":{"docs":{},"当":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"是":{"docs":{},"空":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"（":{"docs":{},"上":{"docs":{},"例":{"docs":{},"）":{"docs":{},"，":{"docs":{},"选":{"docs":{},"择":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"将":{"docs":{},"会":{"docs":{},"为":{"docs":{},"空":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"会":{"docs":{},"出":{"docs":{},"先":{"docs":{},"无":{"docs":{},"法":{"docs":{},"访":{"docs":{},"问":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026}},"是":{"docs":{},"否":{"docs":{},"是":{"docs":{},"拉":{"docs":{},"丁":{"docs":{},"，":{"docs":{},"阿":{"docs":{},"拉":{"docs":{},"伯":{"docs":{},"，":{"docs":{},"中":{"docs":{},"文":{"docs":{},"或":{"docs":{},"者":{"docs":{},"泰":{"docs":{},"语":{"docs":{},"中":{"docs":{},"的":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"4":{"docs":{},"之":{"docs":{},"一":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"，":{"docs":{},"该":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"语":{"docs":{},"句":{"docs":{},"给":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351}}}}}}},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"型":{"docs":{},"可":{"docs":{},"变":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"内":{"docs":{},"可":{"docs":{},"以":{"docs":{},"当":{"docs":{},"做":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}}}},"变":{"docs":{},"量":{"docs":{},"之":{"docs":{},"后":{"docs":{},"除":{"docs":{},"以":{"1":{"0":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}},"docs":{}},"docs":{}}}}}}},"值":{"docs":{},"和":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"当":{"docs":{},"创":{"docs":{},"建":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"总":{"docs":{},"是":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"l":{"docs":{},"l":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"）":{"docs":{},"来":{"docs":{},"暗":{"docs":{},"示":{"docs":{},"值":{"docs":{},"缺":{"docs":{},"失":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"假":{"docs":{},"设":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"知":{"docs":{},"道":{"docs":{},"并":{"docs":{},"记":{"docs":{},"得":{"docs":{},"对":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"判":{"docs":{},"断":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.007518796992481203}},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"该":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"是":{"docs":{},"否":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"/":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"您":{"docs":{},"传":{"docs":{},"递":{"docs":{},"或":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"的":{"docs":{},"是":{"docs":{},"该":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"描":{"docs":{},"述":{"docs":{},"在":{"docs":{},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"是":{"docs":{},"以":{"docs":{},"类":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"前":{"docs":{},"者":{"docs":{},"是":{"docs":{},"以":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"子":{"docs":{},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"表":{"docs":{},"明":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"和":{"docs":{},"实":{"docs":{},"现":{"docs":{},"由":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"1":{"7":{"0":{"1":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"o":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.009398496240601503},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.09523809523809523},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.017921146953405017},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"，":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}},"(":{"docs":{},"章":{"docs":{},"节":{"docs":{},"信":{"docs":{},"息":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}},"的":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"非":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"类":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"类":{"docs":{},"和":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"，":{"docs":{},"析":{"docs":{},"构":{"docs":{},"器":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"下":{"docs":{},"标":{"docs":{},"。":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"该":{"docs":{},"声":{"docs":{},"明":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"里":{"docs":{},"面":{"docs":{},"，":{"docs":{},"你":{"docs":{},"只":{"docs":{},"能":{"docs":{},"为":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"的":{"docs":{},"类":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"因":{"docs":{},"为":{"docs":{},"向":{"docs":{},"下":{"docs":{},"转":{"docs":{},"型":{"docs":{},"而":{"docs":{},"改":{"docs":{},"变":{"docs":{},",":{"docs":{},"当":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"时":{"docs":{},"只":{"docs":{},"被":{"docs":{},"视":{"docs":{},"为":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"类":{"docs":{},"型":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"只":{"docs":{},"有":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"是":{"docs":{},"否":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.02197802197802198}},"前":{"docs":{},"缀":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"生":{"docs":{},"效":{"docs":{},".":{"docs":{},"且":{"docs":{},"@":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"协":{"docs":{},"议":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},",":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},",":{"docs":{},"此":{"docs":{},"外":{"docs":{},",":{"docs":{},"@":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"型":{"docs":{},"协":{"docs":{},"议":{"docs":{},"只":{"docs":{},"对":{"docs":{},"类":{"docs":{},"有":{"docs":{},"效":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"只":{"docs":{},"能":{"docs":{},"在":{"docs":{},"类":{"docs":{},"中":{"docs":{},"检":{"docs":{},"查":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},".":{"docs":{},"详":{"docs":{},"情":{"docs":{},"查":{"docs":{},"看":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}},"特":{"docs":{},"性":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"一":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"就":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"应":{"docs":{},"用":{"docs":{},"到":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"无":{"docs":{},"需":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"它":{"docs":{},"也":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"那":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"添":{"docs":{},"加":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"不":{"docs":{},"能":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"没":{"docs":{},"有":{"docs":{},"标":{"docs":{},"记":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"由":{"docs":{},"标":{"docs":{},"记":{"docs":{},"符":{"docs":{},"组":{"docs":{},"成":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"想":{"docs":{},"把":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"所":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"的":{"docs":{},"实":{"docs":{},"体":{"docs":{},"以":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"命":{"docs":{},"名":{"docs":{},"类":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"把":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"中":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"，":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":5.004149377593361},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"来":{"docs":{},"，":{"docs":{},"当":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"改":{"docs":{},"变":{"docs":{},"时":{"docs":{},"，":{"docs":{},"类":{"docs":{},"就":{"docs":{},"会":{"docs":{},"被":{"docs":{},"通":{"docs":{},"知":{"docs":{},"到":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"任":{"docs":{},"何":{"docs":{},"属":{"docs":{},"性":{"docs":{},"添":{"docs":{},"加":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"它":{"docs":{},"原":{"docs":{},"本":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}},"c":{"docs":{},"c":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"a":{"docs":{},"y":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.006696428571428571},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.003429355281207133}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/01_About_the_Language_Reference.html#gitbook_169":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_169","tf":0.041666666666666664},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.044642857142857144},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.05982905982905983},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.10905349794238683}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.016129032258064516},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":5.009933774834437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.014229249011857707},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.005012531328320802},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.006030150753768844},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"e":{"docs":{},"改":{"docs":{},"成":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"会":{"docs":{},"是":{"docs":{},"什":{"docs":{},"么":{"docs":{},"？":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"当":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"时":{"docs":{},"给":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"特":{"docs":{},"性":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"那":{"docs":{},"些":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"类":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"和":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},")":{"docs":{},"，":{"docs":{},"又":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"可":{"docs":{},"能":{"docs":{},"出":{"docs":{},"现":{"docs":{},"或":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"出":{"docs":{},"现":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"或":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"转":{"docs":{},"换":{"docs":{},"）":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"当":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"确":{"docs":{},"保":{"docs":{},"使":{"docs":{},"用":{"docs":{},"括":{"docs":{},"号":{"docs":{},"给":{"docs":{},"?":{"docs":{},"提":{"docs":{},"供":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"范":{"docs":{},"围":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"说":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"应":{"docs":{},"写":{"docs":{},"作":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},"?":{"docs":{},"，":{"docs":{},"写":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.014619883040935672}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.443209574987787},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.012648221343873518},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.36100131752305664},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.01306532663316583},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.015625},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.009602194787379973}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"位":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}},"前":{"docs":{},"置":{"docs":{},"和":{"docs":{},"后":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}}}}},"按":{"docs":{},"位":{"docs":{},"左":{"docs":{},"移":{"docs":{},"/":{"docs":{},"右":{"docs":{},"移":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}}}},"比":{"docs":{},"较":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}},"溢":{"docs":{},"出":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}},"组":{"docs":{},"合":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}}},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}},")":{"docs":{},"主":{"docs":{},"要":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"：":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}},"’":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}},"按":{"docs":{},"位":{"docs":{},"与":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}},"取":{"docs":{},"反":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}},"异":{"docs":{},"或":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}},"或":{"docs":{},"运":{"docs":{},"算":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}},")":{"docs":{},"三":{"docs":{},"元":{"docs":{},"条":{"docs":{},"件":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}},"）":{"docs":{},"、":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}},"或":{"docs":{},"二":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"会":{"docs":{},"被":{"docs":{},"推":{"docs":{},"测":{"docs":{},"为":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"初":{"docs":{},"值":{"docs":{},"是":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"。":{"docs":{},"就":{"docs":{},"像":{"docs":{},"之":{"docs":{},"前":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"给":{"docs":{},"它":{"docs":{},"们":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"那":{"docs":{},"你":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"给":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"标":{"docs":{},"明":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.02531645569620253}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.007518796992481203}}}},"i":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}},"x":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.003683241252302026},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"标":{"docs":{},"记":{"docs":{},"—":{"docs":{},"—":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"添":{"docs":{},"加":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"就":{"docs":{},"重":{"docs":{},"写":{"docs":{},"父":{"docs":{},"类":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"话":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"同":{"docs":{},"样":{"docs":{},"会":{"docs":{},"检":{"docs":{},"测":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"表":{"docs":{},"明":{"docs":{},"了":{"docs":{},"你":{"docs":{},"是":{"docs":{},"想":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"写":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"错":{"docs":{},"误":{"docs":{},"地":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"意":{"docs":{},"外":{"docs":{},"的":{"docs":{},"重":{"docs":{},"写":{"docs":{},"行":{"docs":{},"为":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"不":{"docs":{},"可":{"docs":{},"预":{"docs":{},"知":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"缺":{"docs":{},"少":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"提":{"docs":{},"醒":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.008617312965139052},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.005025125628140704}},"值":{"docs":{},"的":{"docs":{},"上":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.007712082262210797}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.005141388174807198}}}}}}}}}}}}}}},"s":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.047619047619047616},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}},"k":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}},"枚":{"docs":{},"举":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},",":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.010238907849829351},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.01098901098901099},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.011235955056179775},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.032520325203252036},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0023501762632197414}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}},"l":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.004454342984409799},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0015667841754798276}}}}}}}},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}}},"d":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848}}}}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.026905829596412557},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.02197802197802198},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.06976744186046512},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},".":{"0":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"1":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}},"k":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.02074688796680498}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}},"类":{"docs":{},"也":{"docs":{},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}},"b":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}},"（":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}},"）":{"docs":{},"\\":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"9":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}},"docs":{},"b":{"docs":{},"）":{"docs":{},"、":{"docs":{},"换":{"docs":{},"页":{"docs":{},"符":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"k":{"docs":{},"e":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"i":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}}}},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"m":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483}}}}}}}},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.015228426395939087}}},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"你":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"改":{"docs":{},"变":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"本":{"docs":{},"身":{"docs":{},"不":{"docs":{},"会":{"docs":{},"改":{"docs":{},"变":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"储":{"docs":{},"存":{"docs":{},"这":{"docs":{},"个":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"在":{"docs":{},"后":{"docs":{},"台":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"对":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"改":{"docs":{},"变":{"docs":{},"的":{"docs":{},"是":{"docs":{},"被":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"它":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"显":{"docs":{},"示":{"docs":{},"了":{"docs":{},"基":{"docs":{},"本":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"新":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"3":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"视":{"docs":{},"频":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00404040404040404}}}}}},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403}}}}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.009208103130755065}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.01195814648729447}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}},"x":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.020202020202020204}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"/":{"docs":{},"p":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"或":{"docs":{},"者":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"还":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.006265664160401002}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.005235602094240838},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0066815144766146995}}}}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"6":{"docs":{},"]":{"docs":{},"。":{"docs":{},"这":{"docs":{},"句":{"docs":{},"话":{"docs":{},"访":{"docs":{},"问":{"docs":{},"了":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"第":{"docs":{},"六":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"1":{"8":{"docs":{},"或":{"docs":{},"者":{"6":{"docs":{},"的":{"3":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"e":{"docs":{},"作":{"docs":{},"为":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"开":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0054869684499314125}},")":{"docs":{},"带":{"docs":{},"标":{"docs":{},"签":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"控":{"docs":{},"制":{"docs":{},"传":{"docs":{},"递":{"docs":{},"语":{"docs":{},"句":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":1.1111111111111112}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0071146245059288534},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}},".":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"docs":{}}},"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"4":{"2":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"docs":{}},"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}},"(":{"3":{"docs":{},".":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}},"docs":{}}},"docs":{}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"项":{"docs":{},"的":{"docs":{},"并":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"查":{"docs":{},"找":{"docs":{},"每":{"docs":{},"一":{"docs":{},"项":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"几":{"docs":{},"种":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"直":{"docs":{},"接":{"docs":{},"遍":{"docs":{},"历":{"docs":{},",":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"当":{"docs":{},"做":{"docs":{},"是":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"等":{"docs":{},"类":{"docs":{},"型":{"docs":{},".":{"docs":{},"因":{"docs":{},"此":{"docs":{},"能":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}},"s":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.016260162601626018}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"’":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.007366482504604052},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"s":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"数":{"docs":{},"学":{"docs":{},"公":{"docs":{},"式":{"docs":{},"。":{"docs":{},"它":{"docs":{},"并":{"docs":{},"不":{"docs":{},"适":{"docs":{},"合":{"docs":{},"开":{"docs":{},"放":{"docs":{},"写":{"docs":{},"权":{"docs":{},"限":{"docs":{},"来":{"docs":{},"对":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"只":{"docs":{},"读":{"docs":{},"下":{"docs":{},"标":{"docs":{},"的":{"docs":{},"用":{"docs":{},"法":{"docs":{},"，":{"docs":{},"该":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"用":{"docs":{},"来":{"docs":{},"展":{"docs":{},"示":{"docs":{},"传":{"docs":{},"入":{"docs":{},"整":{"docs":{},"数":{"docs":{},"的":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"三":{"docs":{},"倍":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"数":{"docs":{},"值":{"3":{"docs":{},"作":{"docs":{},"为":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"入":{"docs":{},"参":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"将":{"docs":{},"成":{"docs":{},"为":{"docs":{},"实":{"docs":{},"例":{"docs":{},"成":{"docs":{},"员":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.005494505494505495}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}},"和":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.023809523809523808},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"被":{"docs":{},"写":{"docs":{},"作":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"问":{"docs":{},"号":{"docs":{},"暗":{"docs":{},"示":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"可":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"也":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"值":{"docs":{},"。":{"docs":{},"（":{"docs":{},"不":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"何":{"docs":{},"值":{"docs":{},"比":{"docs":{},"如":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"值":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"。":{"docs":{},"只":{"docs":{},"能":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"i":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}},"k":{"docs":{},"y":{"docs":{},"o":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.013157894736842105}},"s":{"docs":{},"设":{"docs":{},"置":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}},"p":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}}}}}}}}}}}}}}}},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"函":{"docs":{},"数":{"docs":{},".":{"docs":{},"根":{"docs":{},"据":{"docs":{},"函":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"推":{"docs":{},"测":{"docs":{},",":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"可":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"切":{"docs":{},"换":{"docs":{},"或":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"某":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},".":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},",":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0019584802193497847}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"e":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}}}}}}},"那":{"docs":{},"些":{"docs":{},"包":{"docs":{},"含":{"docs":{},"可":{"docs":{},"选":{"docs":{},"成":{"docs":{},"员":{"docs":{},"需":{"docs":{},"求":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"访":{"docs":{},"问":{"docs":{},"可":{"docs":{},"选":{"docs":{},"协":{"docs":{},"议":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"指":{"docs":{},"导":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"不":{"docs":{},"确":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483}},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"u":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.02356020942408377},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.004020100502512563},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.008547008547008548}},"。":{"docs":{},"从":{"docs":{},"字":{"docs":{},"面":{"docs":{},"意":{"docs":{},"思":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"断":{"docs":{},"言":{"docs":{},"“":{"docs":{},"断":{"docs":{},"言":{"docs":{},"”":{"docs":{},"一":{"docs":{},"个":{"docs":{},"条":{"docs":{},"件":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"真":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"断":{"docs":{},"言":{"docs":{},"来":{"docs":{},"保":{"docs":{},"证":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"其":{"docs":{},"他":{"docs":{},"代":{"docs":{},"码":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"某":{"docs":{},"些":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"满":{"docs":{},"足":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"运":{"docs":{},"行":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"进":{"docs":{},"行":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"，":{"docs":{},"会":{"docs":{},"重":{"docs":{},"复":{"docs":{},"运":{"docs":{},"行":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"条":{"docs":{},"件":{"docs":{},"变":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}},"则":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}},"即":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}}}}}}},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"就":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"转":{"docs":{},"到":{"docs":{},"第":{"3":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"都":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"转":{"docs":{},"到":{"docs":{},"第":{"1":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.016597510373443983}}}}},"i":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.44040058622374206},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}},"e":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}},"a":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}},"）":{"docs":{},"的":{"docs":{},"叶":{"docs":{},"子":{"docs":{},"节":{"docs":{},"点":{"docs":{},"传":{"docs":{},"向":{"docs":{},"根":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.003952569169960474},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}}}},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}},"l":{"docs":{},"i":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}},"p":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.667587476979742},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0007905138339920949},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.006030150753768844},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}},"y":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}},"e":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}},"i":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.005376344086021506}},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0071146245059288534},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.004700352526439483}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"常":{"docs":{},"量":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"不":{"docs":{},"能":{"docs":{},"直":{"docs":{},"接":{"docs":{},"相":{"docs":{},"加":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"数":{"docs":{},"字":{"docs":{},"并":{"docs":{},"用":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}},"’":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2582899556583767},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":5.011135857461024},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.47496156739606843},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.443209574987787},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.4476360791326702},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":3.3862977602108035},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":5.013452914798206},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0039169604386995694},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":10.078947368421053},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.3178750897343862},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.01440329218106996}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.007473841554559043},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}},"s":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}},"s":{"docs":{},"(":{"docs":{},"章":{"docs":{},"节":{"docs":{},"信":{"docs":{},"息":{"docs":{},"u":{"docs":{},"r":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}}},"）":{"docs":{},"使":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}}}}},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}},"—":{"docs":{},"—":{"docs":{},"比":{"docs":{},"如":{"docs":{},"表":{"docs":{},"示":{"docs":{},"数":{"docs":{},"字":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"和":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"—":{"docs":{},"—":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"就":{"docs":{},"是":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"知":{"docs":{},"道":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"去":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"新":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.008130081300813009}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"如":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"、":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"外":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"、":{"docs":{},"元":{"docs":{},"组":{"docs":{},"、":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"可":{"docs":{},"选":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"和":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"范":{"docs":{},"围":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},"等":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"一":{"docs":{},"章":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},":":{"docs":{},"特":{"docs":{},"指":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},")":{"docs":{},"中":{"docs":{},"的":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{},"修":{"docs":{},"改":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"修":{"docs":{},"改":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},",":{"docs":{},"而":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"默":{"docs":{},"认":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"修":{"docs":{},"改":{"docs":{},"类":{"docs":{},"型":{"docs":{},",":{"docs":{},"因":{"docs":{},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"前":{"docs":{},"置":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"方":{"docs":{},"便":{"docs":{},"的":{"docs":{},"修":{"docs":{},"改":{"docs":{},"实":{"docs":{},"例":{"docs":{},"及":{"docs":{},"其":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"而":{"docs":{},"无":{"docs":{},"需":{"docs":{},"改":{"docs":{},"变":{"docs":{},"类":{"docs":{},"型":{"docs":{},";":{"docs":{},"而":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"均":{"docs":{},"为":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},"中":{"docs":{},"，":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"是":{"docs":{},"访":{"docs":{},"问":{"docs":{},"某":{"docs":{},"个":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"是":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"本":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"能":{"docs":{},"成":{"docs":{},"功":{"docs":{},"调":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"如":{"docs":{},"果":{"docs":{},"方":{"docs":{},"法":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"的":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"将":{"docs":{},"会":{"docs":{},"是":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.005847953216374269},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00823045267489712}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.014619883040935672},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0102880658436214}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}},"=":{"docs":{},"=":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00205761316872428}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}},"e":{"docs":{},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}},"’":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"。":{"docs":{},"协":{"docs":{},"议":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"—":{"docs":{},"—":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"适":{"docs":{},"配":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"具":{"docs":{},"体":{"docs":{},"类":{"docs":{},"型":{"docs":{},"—":{"docs":{},"—":{"docs":{},"是":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"名":{"docs":{},"字":{"docs":{},"紧":{"docs":{},"跟":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"类":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"候":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"(":{"docs":{},"当":{"docs":{},"然":{"docs":{},"了":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"都":{"docs":{},"知":{"docs":{},"道":{"docs":{},"它":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"了":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"动":{"docs":{},"态":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"吗":{"docs":{},"）":{"docs":{},"。":{"docs":{},"动":{"docs":{},"态":{"docs":{},"类":{"docs":{},"型":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"某":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.011135857461024499}}}},"-":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}}}}}},")":{"docs":{},"是":{"docs":{},"用":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"的":{"docs":{},"(":{"docs":{},"<":{"docs":{},"t":{"docs":{},">":{"docs":{},")":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"那":{"docs":{},"个":{"docs":{},"t":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"t":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"不":{"docs":{},"会":{"docs":{},"去":{"docs":{},"查":{"docs":{},"找":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"别":{"docs":{},"代":{"docs":{},"表":{"docs":{},"t":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"“":{"docs":{},"某":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"”":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{},"后":{"docs":{},"来":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"将":{"docs":{},"来":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"里":{"docs":{},"任":{"docs":{},"何":{"docs":{},"地":{"docs":{},"方":{"docs":{},"表":{"docs":{},"示":{"docs":{},"为":{"docs":{},"“":{"docs":{},"t":{"docs":{},"”":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"）":{"docs":{},"来":{"docs":{},"代":{"docs":{},"替":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"（":{"docs":{},"如":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"或":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"。":{"docs":{},"节":{"docs":{},"点":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"表":{"docs":{},"示":{"docs":{},"t":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"其":{"docs":{},"规":{"docs":{},"定":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"管":{"docs":{},"t":{"docs":{},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"所":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"决":{"docs":{},"定":{"docs":{},"了":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"这":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"容":{"docs":{},"器":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"t":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"子":{"docs":{},"类":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"约":{"docs":{},"束":{"docs":{},"；":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"u":{"docs":{},"，":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"u":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"@":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.02197802197802198}}}}}}}}}}}},"u":{"docs":{},"，":{"docs":{},"v":{"docs":{},"，":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}},"则":{"docs":{},"是":{"docs":{},"跟":{"docs":{},"这":{"docs":{},"些":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"公":{"docs":{},"共":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}}}}}}}}},"和":{"docs":{},"u":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"要":{"docs":{},"求":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"等":{"docs":{},"同":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"样":{"docs":{},"来":{"docs":{},"表":{"docs":{},"达":{"docs":{},"：":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.004219409282700422},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.04935370152761457},"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.029045643153526972},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.014336917562724014},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.011278195488721804},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.022271714922048998},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.01565377532228361},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.011251758087201125},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.011235955056179775},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.03807106598984772},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.05075187969924812},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.028277634961439587},"chapter2/12_Subscripts.html#gitbook_142":{"ref":"chapter2/12_Subscripts.html#gitbook_142","tf":0.016483516483516484},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.013089005235602094},"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.01775147928994083},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.04040404040404041},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.029801324503311258},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0047430830039525695},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.024390243902439025},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.034482758620689655},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.041353383458646614},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.02391629297458894},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.003133568350959655},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.02046783625730994},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.010050251256281407},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0027434842249657062}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23396460929578386},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0037593984962406013},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0029895366218236174},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0011750881316098707}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.005639097744360902}}}}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.002849002849002849},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.004801097393689987}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.004801097393689987}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.00411522633744856}}}}}}}}},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}},"或":{"docs":{},"者":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.0034129692832764505}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"定":{"docs":{},"义":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"只":{"docs":{},"读":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"。":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"）":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"用":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.010752688172043012},"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.2620493541546173},"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.026726057906458798},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":1.6823204419889501},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.012658227848101266},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.44040058622374206},"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":3.370875995449374},"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.005076142131979695},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.020676691729323307},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.45020677322007374},"chapter2/16_Automatic_Reference_Counting.html#gitbook_149":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_149","tf":0.00202020202020202},"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.006622516556291391},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.020553359683794466},"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.04878048780487805},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401},"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.017937219730941704},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.02624363493928711},"chapter3/06_Attributes.html#gitbook_167":{"ref":"chapter3/06_Attributes.html#gitbook_167","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.01507537688442211},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.012658227848101266}},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.007751937984496124}},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"定":{"docs":{},"义":{"docs":{},",":{"docs":{},"其":{"docs":{},"中":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"是":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"键":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.008968609865470852}},"”":{"docs":{},"。":{"docs":{},"不":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"等":{"docs":{},"式":{"docs":{},"符":{"docs":{},"(":{"docs":{},"=":{"docs":{},"=":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"类":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"一":{"docs":{},"个":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"模":{"docs":{},"型":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"没":{"docs":{},"法":{"docs":{},"猜":{"docs":{},"到":{"docs":{},"对":{"docs":{},"于":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"而":{"docs":{},"言":{"docs":{},"“":{"docs":{},"等":{"docs":{},"于":{"docs":{},"”":{"docs":{},"的":{"docs":{},"意":{"docs":{},"思":{"docs":{},"。":{"docs":{},"正":{"docs":{},"因":{"docs":{},"如":{"docs":{},"此":{"docs":{},"，":{"docs":{},"这":{"docs":{},"部":{"docs":{},"分":{"docs":{},"代":{"docs":{},"码":{"docs":{},"不":{"docs":{},"能":{"docs":{},"可":{"docs":{},"能":{"docs":{},"保":{"docs":{},"证":{"docs":{},"工":{"docs":{},"作":{"docs":{},"于":{"docs":{},"每":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.0014947683109118087}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"都":{"docs":{},"关":{"docs":{},"联":{"docs":{},"独":{"docs":{},"特":{"docs":{},"的":{"docs":{},"键":{"docs":{},"（":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_123":{"ref":"chapter2/04_Collection_Types.html#gitbook_123","tf":0.0022271714922048997}}}}}}}}}}}}},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"键":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"些":{"docs":{},"量":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"。":{"docs":{},"当":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"作":{"docs":{},"为":{"docs":{},"输":{"docs":{},"入":{"docs":{},"输":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"加":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}},"可":{"docs":{},"变":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}},"多":{"docs":{},"重":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.23255813953488372}}}}}}}}}}}}}}}}}}}},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":3.333333333333333}}}}}}}}}},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_155":{"ref":"chapter2/19_Nested_Types.html#gitbook_155","tf":0.024390243902439025}}}}}}}}},")":{"docs":{},"，":{"docs":{},"检":{"docs":{},"查":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"所":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"来":{"docs":{},"证":{"docs":{},"明":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"确":{"docs":{},"实":{"docs":{},"是":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"在":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"将":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"值":{"docs":{},"设":{"docs":{},"为":{"2":{"4":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"修":{"docs":{},"改":{"docs":{},"前":{"docs":{},"的":{"docs":{},"值":{"2":{"3":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{},"当":{"docs":{},"其":{"docs":{},"不":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"时":{"docs":{},",":{"docs":{},"?":{"docs":{},"之":{"docs":{},"后":{"docs":{},"语":{"docs":{},"句":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},",":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0012531328320802004}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}},"-":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0013717421124828531}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.004700352526439483}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0037593984962406013}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0023715415019762848},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.024896265560165973}},"e":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"，":{"docs":{},"叫":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"了":{"docs":{},"从":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{},";":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"类":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"基":{"docs":{},"类":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"对":{"docs":{},"所":{"docs":{},"有":{"docs":{},"车":{"docs":{},"辆":{"docs":{},"都":{"docs":{},"通":{"docs":{},"用":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"对":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"来":{"docs":{},"说":{"docs":{},"已":{"docs":{},"经":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"中":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"改":{"docs":{},"变":{"docs":{},"它":{"docs":{},"。":{"docs":{},"而":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"原":{"docs":{},"来":{"docs":{},"的":{"docs":{},"值":{"docs":{},"对":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"来":{"docs":{},"说":{"docs":{},"是":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"中":{"docs":{},"将":{"docs":{},"它":{"docs":{},"更":{"docs":{},"改":{"docs":{},"为":{"2":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"为":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"一":{"docs":{},"辆":{"docs":{},"车":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"些":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_107":{"ref":"chapter2/13_Inheritance.html#gitbook_107","tf":0.004149377593360996}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_135":{"ref":"chapter2/08_Enumerations.html#gitbook_135","tf":0.006825938566552901}}},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"分":{"docs":{},"发":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"之":{"docs":{},"前":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"足":{"docs":{},"够":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"足":{"docs":{},"够":{"docs":{},"多":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"，":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"比":{"docs":{},"请":{"docs":{},"求":{"docs":{},"时":{"docs":{},"小":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"(":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"留":{"docs":{},"在":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"中":{"docs":{},"就":{"docs":{},"返":{"docs":{},"回":{"0":{"docs":{},")":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"声":{"docs":{},"明":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"体":{"docs":{},"的":{"docs":{},"内":{"docs":{},"部":{"docs":{},"修":{"docs":{},"改":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_147":{"ref":"chapter2/15_Deinitialization.html#gitbook_147","tf":0.005917159763313609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.018018018018018018}},"(":{"1":{"docs":{},".":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"docs":{}}},"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.005875440658049354}}}},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"相":{"docs":{},"等":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"相":{"docs":{},"等":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"就":{"docs":{},"是":{"docs":{},"他":{"docs":{},"们":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"x":{"docs":{},"值":{"docs":{},"和":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"单":{"docs":{},"目":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"-":{"docs":{},"a":{"docs":{},"，":{"docs":{},"@":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"也":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"定":{"docs":{},"义":{"docs":{},"和":{"docs":{},"实":{"docs":{},"现":{"docs":{},"一":{"docs":{},"个":{"docs":{},"中":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"在":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"任":{"docs":{},"意":{"docs":{},"两":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"单":{"docs":{},"目":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"将":{"docs":{},"其":{"docs":{},"x":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}},"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.006658832745789268}},".":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"t":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.008438818565400843},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.014367816091954023}},"代":{"docs":{},"替":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}},"。":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407}}}}}}}}}}}}}}},"（":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}},"？":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"当":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"总":{"docs":{},"是":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_151":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_151","tf":0.0033112582781456954}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"空":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},")":{"docs":{},"的":{"docs":{},"别":{"docs":{},"名":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.0029239766081871343}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.005639097744360902}}}}}},"g":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}},"i":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.01015228426395939}},"e":{"docs":{},"中":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"视":{"docs":{},"频":{"docs":{},"显":{"docs":{},"示":{"docs":{},"器":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"四":{"docs":{},"个":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"，":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"具":{"docs":{},"有":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"新":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"会":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"其":{"docs":{},"它":{"docs":{},"三":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"意":{"docs":{},"为":{"docs":{},"“":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"”":{"docs":{},")":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"回":{"docs":{},"放":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"0":{"docs":{},".":{"0":{"docs":{},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"值":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"。":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"意":{"docs":{},"为":{"docs":{},"“":{"docs":{},"没":{"docs":{},"有":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"chapter2/22_Generics.html#gitbook_161":{"ref":"chapter2/22_Generics.html#gitbook_161","tf":0.004484304932735426}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006}}}}}}},"x":{"2":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}},"docs":{}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0023501762632197414},"chapter1/01_swift.html#gitbook_104":{"ref":"chapter1/01_swift.html#gitbook_104","tf":0.047619047619047616},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.007168458781362007},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.01565377532228361},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.0018796992481203006},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.02056555269922879},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.013089005235602094},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.005747126436781609},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0050920485703094395},"chapter3/03_Types.html#gitbook_171":{"ref":"chapter3/03_Types.html#gitbook_171","tf":0.008771929824561403},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.016080402010050253},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.011160714285714286},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.03375527426160337},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.015503875968992248},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0011750881316098707},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018}}}}}},"n":{"docs":{},"n":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}}}},"-":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0027624309392265192}}}}}},"和":{"docs":{},"y":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"没":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"在":{"docs":{},"其":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"修":{"docs":{},"改":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"变":{"docs":{},"量":{"docs":{},"—":{"docs":{},"—":{"docs":{},"程":{"docs":{},"序":{"docs":{},"将":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"临":{"docs":{},"时":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"用":{"docs":{},"相":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"它":{"docs":{},"。":{"docs":{},"修":{"docs":{},"改":{"docs":{},"这":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"只":{"docs":{},"会":{"docs":{},"影":{"docs":{},"响":{"docs":{},"其":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"y":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}},"和":{"docs":{},"z":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"三":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_137":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_137","tf":0.0025380710659898475}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.3042053911619129},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}},"相":{"docs":{},"加":{"docs":{},"，":{"docs":{},"把":{"docs":{},"向":{"docs":{},"量":{"docs":{},"的":{"docs":{},"y":{"docs":{},"相":{"docs":{},"减":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"实":{"docs":{},"际":{"docs":{},"是":{"docs":{},"属":{"docs":{},"于":{"docs":{},"加":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"让":{"docs":{},"它":{"docs":{},"保":{"docs":{},"持":{"docs":{},"了":{"docs":{},"和":{"docs":{},"加":{"docs":{},"法":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"和":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"和":{"1":{"4":{"0":{"docs":{},")":{"docs":{},"。":{"docs":{},"查":{"docs":{},"阅":{"docs":{},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"2":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_102":{"ref":"chapter1/02_a_swift_tour.html#gitbook_102","tf":0.0035252643948296123},"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.019337016574585635},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/10_Properties.html#gitbook_138":{"ref":"chapter2/10_Properties.html#gitbook_138","tf":0.011278195488721804},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.033419023136246784},"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.010471204188481676},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0031620553359683794},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.014367816091954023},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.010575793184488837},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.011055276381909548},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.02531645569620253},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_180","tf":0.023255813953488372},"chapter3/10_Statements.html#gitbook_182":{"ref":"chapter3/10_Statements.html#gitbook_182","tf":0.005698005698005698}},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_111":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_111","tf":0.0018796992481203006}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}}}}}}}}}}}},")":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"余":{"docs":{},"下":{"docs":{},"所":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"横":{"docs":{},"坐":{"docs":{},"标":{"docs":{},"为":{"0":{"docs":{},"的":{"docs":{},"点":{"docs":{},"，":{"docs":{},"并":{"docs":{},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"点":{"docs":{},"的":{"docs":{},"纵":{"docs":{},"坐":{"docs":{},"标":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"临":{"docs":{},"时":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"y":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},":":{"docs":{},"和":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"某":{"docs":{},"个":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"且":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"配":{"docs":{},"到":{"docs":{},"各":{"docs":{},"个":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"种":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"元":{"docs":{},"组":{"docs":{},"(":{"1":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}},"docs":{}}}}}}}}},"-":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.001841620626151013}}}}}},"上":{"docs":{},"，":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"紫":{"docs":{},"色":{"docs":{},"的":{"docs":{},"对":{"docs":{},"角":{"docs":{},"线":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065}}}}}}}}}}}}}},"是":{"docs":{},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_144":{"ref":"chapter2/02_Basic_Operators.html#gitbook_144","tf":0.002617801047120419}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"'":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.002506265664160401}}}},"’":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}}}},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0003916960438699569}}}}}}},"_":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0035842293906810036},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.004604051565377533},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0028129395218002813},"chapter2/11_Methods.html#gitbook_140":{"ref":"chapter2/11_Methods.html#gitbook_140","tf":0.002570694087403599},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_159":{"ref":"chapter2/21_Protocols.html#gitbook_159","tf":0.0037593984962406013},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.003015075376884422},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.013392857142857142},"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.008438818565400843},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0054869684499314125}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0020100502512562816}}}}}}},"、":{"docs":{},"基":{"docs":{},"本":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"面":{"docs":{},"（":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.002232142857142857}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"不":{"docs":{},"关":{"docs":{},"心":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"3":{"docs":{"chapter3/07_Patterns.html#gitbook_178":{"ref":"chapter3/07_Patterns.html#gitbook_178","tf":0.004219409282700422}}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/05_Control_Flow.html#gitbook_125":{"ref":"chapter2/05_Control_Flow.html#gitbook_125","tf":0.0009208103130755065},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.0014064697609001407},"chapter2/20_Extensions.html#gitbook_157":{"ref":"chapter2/20_Extensions.html#gitbook_157","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_173":{"ref":"chapter3/04_Expressions.html#gitbook_173","tf":0.0010050251256281408},"chapter3/02_Lexical_Structure.html#gitbook_176":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_176","tf":0.004464285714285714},"chapter3/09_Summary_of_the_Grammar.html#gitbook_185":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_185","tf":0.0006858710562414266}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/01_The_Basics.html#gitbook_109":{"ref":"chapter2/01_The_Basics.html#gitbook_109","tf":0.0017921146953405018},"chapter2/06_Functions.html#gitbook_127":{"ref":"chapter2/06_Functions.html#gitbook_127","tf":0.005625879043600563},"chapter2/07_Closures.html#gitbook_129":{"ref":"chapter2/07_Closures.html#gitbook_129","tf":0.0028089887640449437},"chapter2/18_Type_Casting.html#gitbook_153":{"ref":"chapter2/18_Type_Casting.html#gitbook_153","tf":0.0015810276679841897},"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.004700352526439483}},"(":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.0007833920877399138}}}},"除":{"docs":{},"零":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_164":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_164","tf":0.30303030303030304}}}}}}}}}}}}}}}}},"length":6780},"corpusTokens":["0","0(空字符)、\\\\(反斜线)、\\t(水平制表符)、\\n(换行符)、\\r(回车符)、\\"(双引号)、\\'","0)中的元素0","0)会首先匹配case","0)可以匹配所有四个case。但是，如果存在多个匹配，那么只会执行第一个被匹配到的case块。考虑点(0","0)将匹配一个纵坐标为0的点，并把这个点的横坐标赋给临时的常量x。类似的，第二个case——cas","0)的case","0)，因此剩下的能够匹配(0","0)，宽度高度都是10","0)，是否在红色的x轴上，是否在黄色y轴上，是否在一个以原点为中心的4x4","0,$1,$2","0,1","0..3","0..count","0..self","0..somecontainer.count","0..time","0.0","0.0125","0.0254","0.1","0.14159","0.25","0.37464991998171","0.5","0.729023776863283","0.914399970739201","00000000","00000001","00000100","00001000","00001111","00010000","00010001","000123.456","00111100","005","005000.76","01111111","02","0746381295[9","08","09","0b","0b00000101","0b00001111","0b00010100","0b00111111","0b01011110","0b10001","0b10110010","0b11110000","0b11111100","0o","0o21","0x","0x000099","0x0000cc","0x0000ff","0x006600","0x00ff00","0x11","0x66","0x99","0xc.3p0","0xcc","0xcc0000","0xcc6699","0xcc6699和0x0000ff进行按位与运算，得到0x000099，无需向右移位了，所以结果就是0x99，即十进制的153","0xcc6699和0x00ff00的按位操作得到0x006600。然后向右移动8們，得到0x66，即十进制的102","0xcc6699和0xff0000进行按位与&操作就可以得到红色部分。0xff0000中的0了遮盖了oxcc6699的第二和第三个字节，这样6699被忽略了，只留下0xcc0000","0xff0000","0xfp-2","0xfp2","0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点原始值还有一个可选的指数，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p","0——编译器会正确的推断出x的类型int。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了let","0。移位过程中保持符号会不变，负数在接近0","0中x的类型首先根据0的类型进行推断，然后将该类型信息传递到根节点（变量x","0为fals","0为true的时候代码运行才会继续，也就是说，当age的值非负的时候。如果age的值是负数，就像代码中那样，ag","0到9.每一个条形码都有一个代表“数字系统”的数字，该数字后接10","0和$1","0和maxpasseng","0始的列表(如数组)时，非常方便地从0","0是真的（true），这将使得choosestepfunction返回stepbackward函数。一个指向返回的函数的引用保存在了movenearertozero","0的数据项的值再次等于"six","0而不是1","0，代表正数，另外7比特位二进制表示的实际值就刚好是4","0，你可以完全忽略类型而简写成var","0，或者对0","0，负数为1","1","1(11111111向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的0","1(11111111向左移1","1)都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。leveltrack","1...3","1...4","1...5","1...amounttopad","1...digitindex","1...finalsquar","1...power","1.0","1.0，1.0","1.21875e1","1.25","1.25e-2","1.25e2","1.5","10","10...99","10.0","100","100...999","100.0","1000...999_999","10000","10000.56","1000000","10000000","1000_000","102","103","105","107","1080","1080i","10^-2","10^2","10^－2","10_000","10_000.56","10中，如果number为16，则返回6，58返回8，510返回0","10为0，这时闭包会将字符串输出，而map","10可以总是作为一个digitnam","10被传递给x","10，同时maxinputlevelforallchannel","11","110","111","11110000","11111110","11111111","11，则会将右声道的currentlevel","12","12,gener","12-side","12.1875","12.5663708","120","123","1234567890123456","123456789[0]返回9","123456789[1]返回8","1234_5678_9012_3456","124","125.0","125.0；同样，1.25e－2","127","128","1280","128054","128054，是一个十六进制1f436","12880","128，即二进制的10000000。用溢出减法减去去1后，变成了01111111，即uint8所能承载的最大整数127","13","130","132","135","139968.0","140","144","15","15)，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性center的值会调用setter来修改属性origin的x和i","15.0","150","153","159","16","16,58,510","160","16。十六进制中每两个字符是8比特位，所以移动16位的结果是把0xcc0000变成0x0000cc。这和0xcc是相等的，都是十进制的204","16变成了1，58变成了5，510变成了51","17","182","19","1920","195.m","1]，编译提也能推断出dict的类型是dictionary<str","1_000.0","1_000_000","1_000_000.000_000_1","1个比特位(称为符号位)来表达这个整数是正数还是负数。0代表正数，1","1位时乘于2，右移1位时除于2","1到5的闭区间数字。index","1千米等于1,000米，所以km计算属性要把值乘以1_000.00来转化成单位米下的数值。类似地，1米有3.28024英尺，所以ft计算属性要把对应的double值除以3.28024","1时才为1","1的条件是两个输入数的同一位不同，如果相同就设为0","1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1","1的比较结果是bool类型，所以第二个例子可以通过类型检查。类似i","1，代表负数，7个数值位要表达的二进制值是124，即128","1：答案2","2","2)。复杂些的运行算包括逻辑与&&","2)中的元组模式(x","2)的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，(x","2,953","2...2","2.0","2.0，4.0","2.5","2.71828","20","200","2000","2001","2014","204","2048","2048像素宽，1080像素高)，cinema的width","21","2100","21位数字(和名称)，例如u+0061表示小写的拉丁字母a","22","23","24","240","243610.0","243_610","25","25.0","25.4.mm","254","255","25，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在方格25","26","29573.0","2^-2","2^2","2_000","2中，加号+是双目运算符，它的两个操作数是值1和2","2倍，非常好，那余数是1","2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128","2的整数。向左移动一个整型的比特位相当于把这个数乘于2，向右移一位就是除于2","2：返回对应的type。我们可以用它来动态的获取某个instance的typ","3","3.0","3.0，1.0","3.1","3.14159","3.1415927","3.14159，0.1和-273.15","3.2","3.28084","3.59","3.69","3.75","3.79","3.ft","3.repetit","30","30.0","32","32767","32768","32位平台上，int和int32","32位平台上，uint和uint32","32华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行if","33","35","35.0","360","3877.0","39","39;&'","39;,'","39;,'分隔。一旦使用了参数列表，就必须使用'in'关键字(在任何情况下都得这样做，包括忽略参数的名字，typ","39;.dynamictype'","39;.self'","39;?'","39;as'","39;in'","39;is'","39;type","39;unowned'","39;weak'","3_000_000_000_000","3可以直接和原始值0.14159","3没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为doubl","3的6倍是18","4","4...9","4.0","4.75会变成4，-3.9会变成-3","40","40.0","404","40华氏度，不算太冷，没必要再围围巾——因此，els","42","42.0","42.km","42495.0","42和-23","42和3.14159","42并且没有标明类型，swift","42被绑定（赋值）给常量somevalu","43","480","4]]，array3d[0][1]是指[3","4]，array3d[0][1][1]则是指值4","4个string","4个元素，但0..count","4而不是0。优先级高的运算符要先计算，在swift和c","4，你先计算出4的多少倍会刚好可以容入9","5","5.0","5.0，5.0","5.2","50","5000.76","510","536","55357","55357)，第二个值为u+dc36","56374","58","59049","597","5乘法表结果。该语句执行后，index","6","6,gener","6-side","6.0","60","60.0","60；同样，0xfp-2","64位平台上，int和int64","64位平台上，uint和uint64","65","66","6699","68","69105","6项，而且不包括mapl","7","7.5","7.simpledescript","70","70.0","72","73","746381295[0","746381295[1","746381295[2","746381295[8","746381295[9","75","77","777","7900","7，类属性maxinputlevelforallchannel","8","8-bit","8.0","8590951226","85909_51226","86","87","896","8:09","8、16、32和64","8位无符号整数类型是uint8，32位有符号整数类型是int32","8除于2.5等于3余0.5，所以结果是0.5","9","9.3","9.45","9.9","90","94","95;_column__","95;_file__","95;_function__","95;_line__","99","9900","9和4代入等式中，我们得1","9和4代入等式，-2","9的行星，通过fromraw返回的可选planet值将是nil","_","_column_","_file_","_function_","_line_","_、基本多语言面（basic","_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了1...3","a++.b","a++，是先返回了a的值，然后a才加1。所以c得到了a的旧值1，而a加1后变成2","a+b","a,b,c","a...b定义一个包含从a到b(包括a和b","a..b定义一个从a到b但不包括b","a.adjust","a.append(4","a.simpledescript","a[0","aardvark","abcdefghijklmnop","abov","absolut","ac","access","accord","ace.toraw","acerawvalu","achiev","act","act1scenecount","action","actual","actual)拷贝才会被执行。swift","actualnumb","actualnumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualnumb","ad","add","addit","addon","addone(numb","address","address。它有三个自判断属性他们额类型是string？。前面两个自判断属性buildingnam","address实例时的使用（john.residence.address）。john.residence属性是一个自判断类型，因此你需要在它获取address","address类中的buildingidentifi","address类还提供了一个buildingidentifier的方法，它的返回值类型为string？。这个方法检查buildingname和buildingnumber的属性，如果buildingname有值则将其返回，或者如果buildingnumb","address设定一个实例来作为john.residence.address的值，并为address的street","addthesecondnumb","addthesecondnumber(b","addtwoint","addtwoints(a","addtwoints和mathfunction有同样的类型，所以这个赋值过程在swift","addtwoints和multiplytwoints。这两个函数都传入两个int","addtwonumbers(4)(5","addtwonumbers(a","adescript","adjust","adopt","advanc","advancetolevel(level","advantag","affect","afterdoubl","afterincr","ag","again","ages的字典，其中储存了四个人的名字和年龄。ages字典被赋予了一个名为copiedages的新变量，同时ages在赋值的过程中被拷贝。赋值结束后，ages和copiedag","airport","airport'","airportcod","airportnam","airports.count","airports.kei","airports.removevalueforkey(\"dub","airports.updatevalue(\"dublin","airports.valu","airports[\"apl","airports[\"dub","airports[\"lhr","airports字典使用字典字面语句初始化，包含两个键值对。第一对的键是tyo，值是tokyo。第二对的键是dub，值是dublin","airports字典被声明为变量（用var关键字）而不是常量（let","airports字典被定义为一种dictionary<str","alex","alia","alias","alien","alignright(originalstr","alignright(var","alignright函数将参数string定义为变量参数。这意味着str","alignright的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串"hello"被转换成了"-----hello"","alik","allitemsmatch","allitemsmatch(stackofstr","allitemsmatch的泛型函数，用来检查是否两个container单例包含具有相同顺序的相同items。如果匹配到所有的items，那么返回一个为true的boolean","allitemsmatch首先检查两个容器是否拥有同样数目的items，如果他们的items数目不同，没有办法进行匹配，函数就会fals","allow","allowedentri","alow","alreadi","alsoincrementbyten","alsominussix","alsoposit","alsoteneighti","alsoteneighty.framer","alsoteneighty的新常量，同时对alsoteneighti","alsotentighti","alt","alt=\"comput","alt=\"stat","alternativerect","alwai","amarathon","ami","amount","amounttopad","amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor","amount和numberoftimes。默认地，swift只把amount当作一个局部名称，但是把numberoftim","amount或者runningtotal来声明在嵌入的incrementor","amount，表示每次incrementor被调用时runningtot","amp","amp;&","amp;&和||的复合逻辑。但无论怎样，&&","amp;/和&%进行除0操作时就会得到0","amp;­identifi","ampersand","and/or","andrea","anim","animal(leg","animalnam","anish","anna","annot","anonym","anoth","anothercharact","anothercontain","anothercontainer.count","anothercontainer[i","anothercontainer中的item","anothercontainer是一个c2","anotheremptystr","anotherint","anothermathfunct","anotherpi","anotherpoint","anotherproctocol","anotherproperti","anotherprotocol","anotherprotocol>这样的格式进行组合,称为协议合成(protocol","anotherstr","anotherthreedoubl","anothertwothre","anothervalu","anothervector","answer","answer1","answer2","ant","anycommonel","anycommonelements([1","anyobject","anyobjectanyobject类型ani","anyobject可以代表任何class","anyth","any可以表示任何类型，除了方法类型（funct","any和anyobject","apart","apartment(numb","apartment实例有一个叫number，类型为int的属性，并有一个可选的初始化为nil的tenant属性。ten","apartment实例的强引用来自于变量number73。如果你断开这个强引用，再也没有指向apart","api","apis，它一般接收一个anyobject[]类型的数组，或者说“一个任何对象类型的数组”。这是因为oc没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的api","apl","app","appear","append","append(item","appending),插入(inserting),删除(removing)或者使用范围下标(rang","append方法添加一个新item","appl","applese","applesummari","appli","approach","appropri","arbitrari","arc","arc为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用arc","arc会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，arc","arc会在引用的实例被销毁后自动将其赋值为nil","arc会在第三个，也即最后一个强引用被断开的时候，销毁person实例，这也意味着你不再使用这个person","arc会跟踪你所新创建的person实例的引用数量，并且会在person","arc会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，arc","arc无法在实例被销毁后将无主引用设为nil，因为非可选类型的变量不允许被赋值为nil","arc销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上weak","area","argument","argyrio","arithmet","arithmeticmean(1","arithmeticmean(3","arithmeticmean(numb","around","arrai","array<int>>","array<int>替代泛型类型array<t>的类型形参t","array<sometype>这样的形式，其中sometyp","array(airports.kei","array(airports.valu","array(count","array)和字典(dictionari","array)，字典(dictionary)，范围（range），字符串（str","array-liter","array-literal-item","array-literal-items­opt","array-literal-item­,­(opt","array-literal-item­,­array-literal-item","array-typ","array3d","array3d[0]是指[[1","array提示check","class_protocol","class、deinit、enum、extension、func、import、init、let、protocol、static、struct、subscript、typealias、var","class关键字来表示该属性为类成员;用结构体或枚举实现协议时,则使用stat","class关键字表示协议中的成员为类成员;当协议用于被枚举或结构体遵循时,则使用stat","class前添加@final特性（@fin","class和struct","class类型。它创建了一个可以存储ani","class）来将整个类标记为fin","claus","close","closer","closest","clossur","closur","closure)包含了可执行的代码(跟方法主体(stat","closure-express","closure-signatur","closure-signature­opt­stat","closures(需要arc","club","cluster","cm","cocoa","cocoa的基础上构建框架栈并将其标准化。objective-c","cocoa里的nslog函数一样，println","code","code-block","code>$0、$1、$2`。例如，class`class`。反引号不属于标识符的一部分，`x`(x","comparable等同于t","comparable表示任何用于替代类型形参t的类型实参必须满足compar","comparable，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，<t","compasspoint","compasspoint.west","compasspoints例子中，north，south，east和west不是隐式得等于0，1，2和3。相反的，这些不同的枚举成员在compasspoint","compasspoint和planet","compil","compile-tim","complement","complet","completedlevel(level","complex","compon","composit","compound","comput","computedtypeproperti","concaten","concept","condit","condition(item","conditional-oper","conditional-operator­prefix-express","condition的值在statements执行前就已计算出，因此while语句中的stat","condition表达式的值是在statements表达式执行后才计算出，因此do-while语句中的stat","condition表达式的值的类型必须遵循logicvalue协议。同时，condit","confid","conform","conformance-requir","conformance(arrai","equatable类型都可以安全的使用在findindex函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个equat","equatable，也就意味着“任何t类型都遵循equat","equilater","equilateraltriangl","equilateraltriangle(sidelength","equival","error","error(error","error(str","escaped-charact","essenc","evalu","even","everyth","ewa","eww","exact","exactli","exampl","exampleclass","examplemodule.mytyp","exampleprotocol","except","exclus","execut","exist","expect","explan","explicit","explicit-member-express","explicitdoubl","explicitli","exponentdoubl","export","express","expression)dynamic表达式(dynam","expression)self表达式(self","expression)。起保护作用的表达式是这样构成的：关键字where后面跟着一个作为额外测试条件的表达式。因此，当且仅当控制表达式匹配一个case的某个模式且起保护作用的表达式为真时，对应case块中的statements才会被执行。在下面的例子中，控制表达式只会匹配含两个相等元素的元组，如(1","expression)会首先被计算，然后与每一个case的模式(pattern)进行匹配。如果匹配成功，程序将会执行对应的case块里的statements。另外，每一个case块都不能为空，也就是说在每一个case块中至少有一条语句。如果你不想在匹配到的case块中执行代码，只需在块里写一条break","expression)初始化函数表达式(initi","expression)可选链表达式(optional-chain","expression)后缀self表达式(postfix","expression)圆括号表达式(parenthes","expression)强制取值表达式(forced-valu","expression)显式成员表达式(explicit","expression)超类表达式(superclass","expression)闭包表达式(closur","expression)隐式成员表达式(implicit","expression)，switch","expression-el","expression-element-list","expression-element­,­expression-element-list","expression-list","expression-pattern","expression.dynamictyp","expression.init(initi","expression.memb","expression.self","expression[index","expressions)sort","expressions)前缀表达式(prefix","expressions)字符型表达式(liter","expression­,­expression-list","expression­:­express","expression）。通常会增加或减少计数器的值，或者根据语句（statements）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第2","exp，那这个数相当于基数和10^exp","exp，那这个数相当于基数和2^exp","extend","extens","extension-bodi","extension-declar","extension][6","extension][7","extern","extra","f","face字符的utf-16","face的4","face的unicod","face，unicod","factor","fail","failur","fall","fallthrough","fallthrough-stat","fallthrough关键字不会检查它下一个将会落入执行的case中的匹配条件。fallthrough简单地使代码执行继续连接到下一个case中的执行代码，这和c语言标准中的switch","fallthrough语句可出现在switch语句中的任意case里，但不能出现在最后一个case块中。同时，fallthrough语句也不能把控制权传递给使用了可选绑定的cas","fallthrough语句用于在switch语句中传递控制权。fallthrough语句会把控制权从switch语句中的一个case传递给下一个case。这种传递是无条件的，即使下一个case的值与switch","fals","false。同样的，item","false。这类循环适合使用在第一次迭代前迭代次数未知的情况下。swift","false，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是tru","false，整个表达式的值就为false。事实上，如果第一个值为fals","familiar","feed","feed）\\n","feed）（u+000a）、回车符（carriag","feed）（u+000c）以及空（null）（u+0000","feet","few","fibonacci","file","file)，它返回的是当前modul","filenam","fill","film","final","finalsquar","finalsquare,board,square和dicerol","finalsquare,这表明你必须刚好落在方格25","finalsquare，board，squar","final方法，属性或下标，在编译时会报错。在扩展中，你添加到类里的方法，属性或下标也可以在扩展的定义里标记为fin","final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@fin","find","findindex([\"mik","findindex([3.14159","findindex(arrai","findindex中这个单个类型参数写做：t","findindex函数现在则可以成功的编译过，并且作用于任何遵循equatable的类型，如double或str","findindex，用某个类型t","findstringindex","findstringindex(arrai","findstringindex(str","findstringindex的泛型版本findindex。请注意这个函数仍然返回int","findstringindex的非泛型函数，该函数功能是去查找包含一给定string值的数组。若查找到匹配的字符串，findstringindex函数返回该字符串在数组中的索引值（int），反之则返回nil","first","first-class）类型。它们采用了很多传统上只被类所支持的特征，例如计算型属性（comput","firstbit","firstbits和otherbits都有一个1跟另一个数不同的。所以按位异或的结果是把它这些位置为1，其他都置为0","firstforloop","firstitem","firstprotocol","firstroomnam","firstsixbit","firstsixbits和lastsixbits中间4个位都为1。对它俩进行按位与运算后，就得到了00111100，即十进制的60","firstvalu","firstvector","fit","five","fiveeight","fiveonezero","fixedincr","fixedlengthrang","fixedlengthrange(firstvalu","fixedlengthrange的实例包含一个名为firstvalue的变量存储属性和一个名为length的常量存储属性。在上面的例子中，length","fixedpoint","fixedpoint.movebyx(2.0","flat","flexibl","float","floating-point","floating-point-","floating-point-liter","floating-point-p","float并指定初始值为4","float表示32","flour","flow章节有该游戏的详细介绍)游戏的新版本.新版本使用dice作为骰子,并且实现了dicegame和dicegamedeleg","follow","for-condition-incr","for-condition-increment循环体中，在调用continu","for-in","for-in-stat","for-infor条件递增（for-condition-increment）whil","for-init","for-in循环和半闭区间操作(..)来迭代somecontainer中的所有items。对于每个item，函数检查是否somecontainer中的item不等于对应的anothercontainer中的item，如果这两个items不等，则这两个容器不匹配，返回fals","for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都由(kei","for-in循环的介绍请参见for","for-in循环请参见for","for-in语句允许在重复执行代码块的同时，迭代集合(或遵循sequ","for-in语句在循环开始前会调用collection表达式的generate方法来获取一个生成器类型（这是一个遵循generator协议的类型）的值。接下来循环开始，调用collection表达式的next方法。如果其返回值不是none，它将会被赋给item，然后执行statements，执行完毕后回到循环开始处；否则，将不会赋值给item也不会执行statements，for-in","for-in语句或者变量或常量申明时，它可以包含通配符模式，标识符模式或者其他包含这两种模式的模式。例如，下面这段代码是不正确的，因为(x","for-stat","forc","force-unwrap","forced-valu","forced-value-express","forget","forincr","forkei","form","for—that","for条件递增（for-condition-incr","for语句、for-in语句、while语句和do-whil","for语句中，continue语句执行后，increment表达式还是会被计算，这是因为每次循环体执行完毕后incr","found","found"","found")元组把一个int值和一个str","foundat","foundindex","four","fourbyfivebytwo","fourbyfivebytwo.volum","framer","freedom","friar","friendlywelcom","friendlywelcome的值从"hello!"改为了"bonjour!"","fromraw方法来试图找到具有特定原始值的枚举成员。这个例子通过原始值7识别uranu","fromthetop","fruit","fruitsummari","ft","fullnam","fullynam","fullynamed协议含有fullname属性.因此其遵循者必须含有一个名为fullname,类型为str","func","function","function)中，__function__","function-bodi","function-call-express","function-declar","function-head","function-nam","function-result","function-signatur","function-typ","functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即逆向建模）。扩展和objective-c中的分类(categories)类似。（不过与objective-c不同的是，swift","functions运算符函数prefix","functions）函数参数与返回值（funct","functions）函数的定义与调用（defin","functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nest","function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数addtwonumber()()的类型是int","func作为前缀。指定函数返回类型时，用返回箭头->","func关键字之前加上关键字class；声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字stat","func来声明一个函数，使用名字和参数来调用函数。使用->","g","game","game(gam","game,d12,simothehamst","game.deleg","game.dice.sides)-sid","game.plai","gamedidend(gam","gamedidstart(gam","gamedidstart方法从game参数获取游戏信息并输出.game在方法中被当做dicegame类型而不是snakeandladders类型,所以方法中只能访问dicegam","gameloop","gameloop去跳转到下一次循环迭代时，这里使用gameloop标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以continue语句会影响到哪个循环体是没有歧义的。然而，continue语句使用gameloop标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的break","gameloop语句结束本次whil","gameloop语句跳转控制去执行whil","gear","gener","generator.random","generic-argu","generic-argument-claus","generic-argument-clause[opt","generic-argument-clause[opt].type-identifi","generic-argument-list","generic-argument­,­generic-argument-list","generic-paramet","generic-parameter-claus","generic-parameter-list","generic-parameter­,­generic-parameter-list","getgaspric","gettable,但它不要求属性是存储型属性(stor","getter","getter-claus","getter-keyword-claus","getter-sett","getter-setter-block","getter-setter-keyword-block","getter-setter方法​​块可以由一个getter子句后跟一个可选的setter子句构成，用大括号括起来，或者由一个setter子句后跟一个gett","getter/sett","getters和sett","getter和sett","getter获取某个值，或者通过sett","getter（或sett","get代码块中的代码写在subscript","get关键字表示。它们的返回值是double型，而且可以用于所有接受doubl","ghostbust","give","given","global","goe","gonna","good","goodby","graham","grai","grammar","graphem","graphic","great","green","greencompon","greet","greet(\"bob","greet(nam","greeting被调用，该函数结束它的执行并返回greet","grid","grid[(row","group","grtmndsthnklk","gt","gt;>","gt;"","gt;！&","guard","guard-claus","guard-express","guess","guide，即便你没有实现它。例如：swift的array和dictionary类型都是泛型集。你可以创建一个int数组，也可创建一个string数组，或者甚至于可以是任何其他swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(dictionari","h","half-clos","halfopenrangelength(start","hall","halv","hamster","hamster(nam","hamster的实例可以作为textrepresent","handl","happen","happi","harmless","hasanymatches(list","hasanymatches(numb","hasarea","hasarea协议时,通过as?操作符将其可选绑定(opt","hasdoorkei","hasdoorkey为false，但第二个值knowsoverridepassword为true，所以整个表达是tru","hash","hashabl","hashable和valuetype产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何where语句所指定的额外的要求。上面的例子中，类型形参keytype要求满足hashable协议，因此string也必须满足hash","hashead","hashtabl","hasprefix","hasprefix/hassuffix","hawk","hd","hd.width","hd实例中width属性还是1920","hd的常量，其值为一个初始化为全高清视频分辨率(1920像素宽，1080像素高)的resolut","hd赋予给cinema的时候，实际上是将hd中所储存的值(values)进行拷贝，然后将拷贝的数据储存到新的cinema实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将cinema的width修改为2048并不会影响hd中的宽(width","heart","hearts.simpledescript","heartsdescript","heartssymbol","hearts成员：给hearts常量赋值时，枚举成员suit.hearts需要用全名来引用，因为常量没有显式指定类型。在switch里，枚举成员使用缩写.hearts来引用，因为self的值已经知道是一个suit","heathrow","height","height=\"120","height=\"169","height=\"288","height=\"290","height=\"357","height=\"387","heigth","hello","hello-world","help","here","here'","here’","hexadecim","hexadecimal-digit","hexadecimal-expon","hexadecimal-fract","hexadecimal-liter","hexadecimal-literal-charact","hexadecimaldoubl","hexadecimalinteg","hierarchi","high","higher","higher-preced","highest","highestunlockedlevel","highland","hilari","hold","horizont","horribl","hors","htmlelement","htmlelement(nam","htmlelementdeinitializer中的消息并没有别打印，证明了htmlel","htmlelement例子中，无主引用是正确的解决循环强引用的方法。这样这样编写htmlel","htmlelement实现和之前的实现一致，只是在ashtml闭包中多了一个占有列表。这里，占有列表是[unown","htmlelement类产生了类实例和ashtml","htmlelement类只提供一个构造函数，通过name和text(如果有的话)参数来初始化一个元素。该类也定义了一个析构函数，当htmlel","htmlelement类定义了一个name属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。htmlelement还定义了一个可选属性text，用来设置和展现html","htmlelement还定义了一个lazy属性ashtml。这个属性引用了一个闭包，将name和text组合成html","http","http200statu","http200status.descript","http200status.statuscod","http404error","http404error.0","http404error.1","human","hundr","i++的特性，不然推荐你使用++i和--i","iboutlet和ibinspectable用于修饰一个类的属性声明；ibaction特性用于修饰一个类的方法声明；ibdesign","ident","identifi","identifier-charact","identifier-head","identifier-list","identifier-list­function-result­(opt)­in","identifier-pattern","identifier-patterntype-annotationopt","identifier­:­express","identifier­generic-argument-clause­(opt","if-condit","if-stat","if和let来处理值缺失的情况。有些变量的值是可选的。一个可选的值可能是一个具体的值或者是nil","if和switch来进行条件操作，使用for-in、for、while和do-whil","if和while语句中来对可选的值进行判断并把值赋给一个常量或者变量。if和whil","if或els","if语句中条件的值的类型必须遵循logicvalu","if语句中，条件必须是一个布尔表达式——这意味着像if","if语句允许二选一，也就是当条件为假时，执行els","if语句和switch","if语句和switch语句。通常，当条件较为简单且可能的情况很少时，使用if语句。而switch语句更适用于复杂的条件、可能的情况很多且需要用到模式匹配(pattern-match","if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是fals","if语句用于判断是不是特别热。而最后的els","if语句的第一个分支中操作actualnumber的值，你可以改成if","if！allowedentri","ignor","illustr","imag","img","immedi","implement","implicit","implicit-member-express","implicit-parameter-nam","implicitdoubl","implicitinteg","implicitli","implicitly-unwrapped-optional-typ","implicitlyunwrappedoptional泛型实参语句泛型形参语句泛型形参语句where语句hello","pad","paddeddoubl","paddedstr","paint","pair","paragraph","paragraph变量为nil，打破它持有的htmlelement实例的强引用，htmlel","paragraph变量定义为可选htmlelement，因此我们可以赋值nil","parakeet","paramet","parameter),不支持默认参数(default","parameter-claus","parameter-clause­function-result­(opt)­in","parameter-list","parameter-nam","parameternam","parameters"","parameters(这里需要closur","parameters类型参数命名类型参数泛型类型类型约束类型约束语法类型约束行为关联类型关联类型行为扩展一个存在的类型为一指定关联类型wher","parameters）函数类型（funct","parameters）常量参数和变量参数（const","parameters）无参函数（funct","parameters）无返回值函数（funct","parameters）输入输出参数（in-out","parameter’","parent","parenthes","parenthesized-express","part","particular","pass","passedretinascan","passedretinascan)，还有自增运算符++i","passeng","pattern","pattern-initi","pattern-initializer-list","patternastyp","patterns）表达式模式（express","patterns）通配符模式（wildcard","pattern）代表了单个值或者复合值的结构。例如，元组(1","pattern）值绑定模式（value-bind","pattern）元组模式（tupl","pattern）和元组模式（tupl","pattern）枚举案例模式（enumer","pattern）标识符模式（identifi","pattern）类型转换模式（type-cast","pattern），标识符模式（identifi","penguin","pepper","perform","performact","perimet","person","person'","person(fullnam","person(nam","person?的变量，用来按照代码片段中的顺序，为新的person实例建立多个引用。由于这些变量是被定义为可选类型(person?，而不是person)，它们的值会被自动初始化为nil，目前还不会引用到person","personnam","person和apart","person和apartment实例并将类实例赋值给john和number73","person和apartment的例子一致，但是有一个重要的区别。这一次，apartment的ten","person和apartment的例子展示了两个属性的值都允许为nil","person和resid","person和residence模型通过添加一个room和一个address","person实例依然保持对apartment实例的强引用，但是apartment实例只是对person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向person","person实例有一个类型为string，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apart","person实例现在有了一个指向apartment实例的强引用，而apartment实例也有了一个指向person实例的强引用。因此，当你断开john和number73变量所持有的强引用时，引用计数并不会降为0，实例也不会被arc","person实例，它的resid","person类开始，并定义了一个叫nam","person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。person","person类的新实例被赋值给了reference1变量，所以reference1到person类的新实例之间建立了一个强引用。正是因为这个强引用，arc会保证person","person类的构造函数的时候，"john","person结构体含有一个名为fullnam","peter","pi","piec","pink","pixel","place","placehold","plai","plane","planet","planet.earth","planet.earth.toraw","planet.fromraw(7","planet.fromraw(9)语句获得一个可选planet，如果可选planet可以被获得，把someplanet设置成该可选planet的内容。在这个范例中，无法检索到位置为9的行星，所以els","planet.fromraw(positiontofind","planet.uranu","planet.venus的原始值是2","player","player(coin","player(nam","player.completedlevel(1","player.tracker.advancetolevel(6","playernam","playeron","playerone!.coinsinpurs","playerone!.wincoins(2_000","playerone是可选的，所以由一个感叹号(!)来修饰，每当其wincoins方法被调用时，coinsinpurs","player实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在bank初始化的过程中得到。如果没有足够的硬币可用，play","player实例随着一个100个硬币(如果有)的请求而被创建。这个player实例存储在一个名为playerone的可选player变量中。这里使用一个可选变量，是因为players可以随时离开游戏。设置为可选使得你可以跟踪当前是否有play","player已经赢得了2,000硬币。player的钱包现在有2,100硬币，bank只剩余7,900","player现在已经离开了游戏。这表明是要将可选的playerone变量设置为nil，意思是"没有player实例"。当这种情况发生的时候，playerone变量对player实例的引用被破坏了。没有其它属性或者变量引用player实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到bank","player类使用leveltrack","player类创建一个新的leveltracker实例来检测这个用户的发展进度。他提供了completedlevel方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了advancetolevel返回的布尔值，因为之前调用leveltracker.unlocklevel","player类定义了一个wincoins方法，该方法从bank获取一定数量的硬币，并把它们添加到player的钱包。player类还实现了一个析构函数，这个析构函数在player实例释放前一步被调用。这里析构函数只是将player的所有硬币都返回给bank","player类描述了游戏中的一个玩家。每一个player在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过player的coinsinpurs","pleas","plu","plusminusvector","plusthre","pm","point","point(x","point.0","point.1","pointonefouronefivenin","point封装了一个(x","point来引用元组(int","point结构体定义了一个变异方法(mut","pop","popul","popviewcontrolleranim","pop并移除值"cuatro"","pop方法的返回值，该返回值将是一个t","port","posit","positiontofind","possibl","possibleinteg","possibleintegervalu","possiblenumb","possiblenumber.toint","possiblenumber.toint返回的可选int包含一个值，创建一个叫做actualnumb","possibleplanet","possiblestr","postfix","postfix-express","postfix-expression­.­decimal-digit","postfix-expression­.­dynamictyp","postfix-expression­.­identifier­generic-argument-clause(opt","postfix-expression­.­init","postfix-expression­.­self","postfix-expression­[­expression-list","postfix-expression­parenthesized-express","postfix-expression­parenthesized-expression­(opt)­trailing-closur","postfix-expression­postfix-oper","postfix-oper","postfix-operator-declar","postfix-self-express","potentialoverflow","powder","power","preced","precedence-claus","precedence-level","predefin","predict","prefix","prefix)表达式，二元(binary)表达式，主要(primary)表达式和后缀(postfix)表达式。表达式可以返回一个值，以及运行某些逻辑(caus","prefix-express","prefix-expression­binary-expressions(opt","prefix-oper","prefix-operator-declar","prefix存在时,将prefix插入到name之前来为starship构建fullnam","preslei","prettytextrepresent","prettytextrepresentable协议的同时,也需要遵循textrepresent","prettytextrepresentable协议继承了textrepresent","primari","primary-express","prime","principl","print","print(\"\\(codeunit","print(\"\\(scalar.valu","print(\"\\n","print(\"conson","print(\"oth","print(\"vowel","print(parent!.titl","print(self!.titl","print(self.titl","printandcount(\"hello","printandcount(stringtoprint","printandcount，输出一个字符串并返回int类型的字符数。第二个函数printwithoutcount","printclassnam","printhelloworld","printletterkinds(\"hello","printletterkinds(word","printletterkinds的输入是一个string值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的kind计算属性，并打印出合适的类别描述。所以printletterkinds就可以用来打印一个完整单词中所有字母的类型，正如上述单词"hello"","println","println(\"'\\\\(word","println(\"(0","println(\"(\\(point.0","println(\"(\\(somepoint.0","println(\"(\\(x","println(\"3的6倍是\\(threetimestable[6","println(\"\\(airportcod","println(\"\\(animalname)","println(\"\\(bas","println(\"\\(country.name)'","println(\"\\(currentvalu","println(\"\\(index","println(\"\\(nam","println(\"\\(possiblenumb","println(\"\\(scalar","println(\"\\(somecharact","println(\"\\(total.vowel","println(\"a","println(\"about","println(\"access","println(\"ad","println(\"airport","println(\"al","println(\"an","println(\"and","println(\"apart","println(\"area","println(\"automaticcar","println(\"b","println(\"bicycl","println(\"car","println(\"card","println(\"cinema","println(\"count","println(\"eww","println(\"gam","println(\"goodby","println(\"happi","println(\"hd","println(\"hello","println(\"here'","println(\"highest","println(\"index","println(\"it","println(\"it'","println(\"item","println(\"john'","println(\"level","println(\"lot","println(\"media","println(\"mmm","println(\"mostli","println(\"movi","println(\"not","println(\"on","println(\"play","println(\"playeron","println(\"qr","println(\"random","println(\"result","println(\"rol","println(\"som","println(\"somebaseclass","println(\"someint","println(\"somesubclass","println(\"someth","println(\"somewher","println(\"song","println(\"speedlimitedcar","println(\"square.origin","println(\"start","println(\"tandem","println(\"tentighti","println(\"th","println(\"that","println(\"theaceofspad","println(\"ther","println(\"thes","println(\"thi","println(\"thre","println(\"un","println(\"unusualmenageri","println(\"upc-a","println(\"watch","println(\"welcom","println(\"wher","println(\"zero","println(a[0","println(ages[\"pet","println(assumedstr","println(audiochannel.maxinputlevelforallchannel","println(b[0","println(c[0","println(cat","println(charact","println(counter.count","println(d12.astext","println(definitestr","println(descript","println(friendlywelcom","println(game.asprettytext","println(game.astext","println(halfopenrangelength(1","println(item","println(leftchannel.currentlevel","println(manager.importer.filenam","println(messag","println(name[0","println(paragraph!.ashtml","println(possiblestr","println(puzzleoutput","println(rightchannel.currentlevel","println(sayhello(\"anna","println(sayhello(\"brian","println(sayhelloagain(\"anna","println(sayhelloworld","println(someclass.computedtypeproperti","println(somestructure.storedtypeproperti","println(somethingtextrepresentable.astext","println(stringtoprint","println(thing.astext","println(“th","println函数输出传入的str","println是一个用来输出的全局函数，输出的内容会在最后带换行。如果你用xcode，println将会输出内容到“console”面板上。(另一种函数叫print","printmathresult(addtwoint","printmathresult(mathfunct","printmathresult函数的作用就是输出另一个合适类型的数学函数的调用结果。它不关心传入函数是如何实现的，它只关心这个传入的函数类型是正确的。这使得printmathresult可以以一种类型安全（type-saf","printmathresult函数，它有三个参数：第一个参数叫mathfunction，类型是(int","printmathresult被调用时，它被传入addtwoints函数和整数3和5。它用传入3和5调用addtwoints，并输出结果：8","printnumberofroom","prints\"hello","printwithoutcounting(\"hello","printwithoutcounting(stringtoprint","prioriti","privat","process","procotol","productbarcod","productbarcode的新变量，并且赋给它一个barcode.upca的关联元组值(8","productcod","program","properti","properties)，用于提供关于枚举当前值的附加信息，实例方法（inst","property),也能够要求属性的(设置权限)sett","property)在实例方法中修改值类型(modifi","property)还是计算型属性(calcul","property）还是计算型属性（comput","property），或下标（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overrid","protoc","protocol","protocol<protocol","protocol<someprotocol","protocol-associated-type-declar","protocol-bodi","protocol-composition-typ","protocol-declar","protocol-identifi","protocol-identifier-list","protocol-initializer-declar","protocol-member-declar","protocol-method-declar","protocol-nam","protocol-property-declar","protocol-subscript-declar","protocol(item","repeatedvalu","repeatedvalue:0.0","repetit","repetitions(task","report","repres","represent","request","requir","requirement-claus","requirement-list","requirement­,­requirement-list","reserv","reset","reset将计数器重置为0","resid","residence中也提供了一个printnumberofroom","residence具有一个int类型的numberofrooms，其值为1。person具有一个自判断residence属性，它的类型是resid","residence存储了一个room实例的数组，它的numberofrooms属性值不是一个固定的存储值，而是通过计算而来的。numberofrooms属性值是由返回rooms数组的count","residence定义了一个自判断属性叫address（address？）。address","residence实例给john.resid","residence实例给john.residence，且在他的rooms数组中有一个或多个room实例，那么你可以使用可选链通过residence子脚本来获取在room","residence属性numberofrooms属性值，将会引发运行时错误，因为这时没有可以供解析的resid","residence的printnumberofrooms方法会打印numberofroom","residence类中定义的子脚本来获取john.residence数组中第一个房间的名字。因为john.residence现在是nil","resolut","resolution()或videomode()。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。initi","resolution(width","resolution的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为width和height的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数0的时候，它们会被推断为int","resolution结构体和videomode类的定义仅描述了什么是resolution和videomode。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video","resolution（width:640","respond","result","result(str","result(sunris","retriev","return","return-stat","returnfifteen","returntyp","return时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为void","return语句后面带表达式时，表达式的值将会返回给调用者。如果表达式值的类型与调用者期望的类型不匹配，swift","return语句时，可以只写return这个关键词，也可以在return","return）\\r","return）或换行符（lin","return）（u+000d","revers","rh","rhsitem","rich","rick","ridlei","right","right-associ","right-hand","right.i","right.x","rightchannel","rightchannel.currentlevel","rise","role","roll","roll方法用来模拟骰子的面值.它先使用generator的random方法来创建一个[0-1","romeoandjuliet","room","room(","room(nam","roomcount","rooms.count","rooms[i","rooms数组的room类是一个很简单的类，它只有一个name属性和一个设定room","rooms数组，resid","rooms，它被初始化为一个room","round","row","row0","row1","rowheight","rowheight定义成变量，因为它的值无需在if","row和column下标的matrix","row和column的数量来构造一个新的matrix","rule","runingtotal变量的内存管理操作，如果不再被incrementor","runningtot","runningtotal增加amount","runningtotal的值，incrementor捕获了当前runningtotal变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeincrementor结束时候并不会消失，也保证了当下一次执行incrementor函数时，runningtot","runtim","s","s1","s2","s2)，backwards函数返回true，表示在新的数组中s1应该出现在s2","safe","safeti","same","same-type-requir","samequot","sampl","sandwich","sankesandladders的实例都可以使用asprettytext","saturn","saygoodbye(\"dav","saygoodbye(personnam","saygoodbye函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫void。它其实是一个空的元组（tupl","sayhello(personnam","sayhelloagain(personnam","sayhelloworld","sayhello。上面的例子展示的是用"anna"和"brian"","sayhello函数时，在圆括号中传给它一个string类型的实参。因为这个函数返回一个string类型的值，sayhello可以被包含在println","sayhello函数的另一个版本，叫wavegoodbye，这个函数直接输出str","sayhello的函数体中，先定义了一个新的名为greeting的string常量，同时赋值了给personname的一个简单问候消息。然后用return关键字把这个问候返回出去。一旦return","scalar","scarf","scene","scene.hasprefix(\"act","scope","score","scott","second","secondforloop","secondvector","see","seem","self","self(initi","self-express","self.anm","self.area","self.artist","self.capitalc","self.column","self.count","self.countri","self.custom","self.director","self.gener","self.greet","self.init(initi","self.init(origin","self.leg","self.memb","self.nam","self.name)>\\(text)(somet","someresolut","someresolution.width","someresolution.width引用someresolution的width属性，返回width的初始值0","somestr","somestring变量通过字符串字面量进行初始化，swift","somestructur","somestructure.storedtypeproperti","somestructure等），以便符合标准swift","somesubclass","somesuperclass","somesupertyp","someth","somethingtextrepresent","sometuple的类型被指定为(doubl","sometuple：(doubl","sometyp","sometype(ofinitialvalu","sometypemethod","sometypeproperti","someu","somevalu","somevalue是一个标识符模式，匹配了类型是int的42","somevehicl","somevideomod","somevideomode.resolution.width","somevideomode中resolution属性的width这个子属性，以上操作并不需要从新设置resolut","somewher","song","song(nam","song.artist","song.nam","songcount","songcount，用来计算数组librari","song检查item是否为song类型的实例。在循环末尾，moviecount","sort","sort([1","sort(nam","sort函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回true，反之返回fals","sort函数的参数进行传入的，swift","sort期望第二个参数是类型为(str","soup","sourc","south","space","space）（u+0020）、换行符（lin","spade","span","sparklingheart","special","specif","specifi","speed","speedlimitedcar","speedlimitedcar实例的speed属性时，属性setter的实现会去检查新值与限制值40mph的大小，它会将超类的speed设置为newvalue和40.0中较小的那个。这两个值哪个较小由min函数决定，它是swift标准库中的一个全局函数。min","speedlimitedcar实例的speed属性设置为一个大于40mph的数，然后打印description函数的输出，你会发现速度被限制在40mph","speedlimitedcar，它是car的子类。类speedlimitedcar表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的spe","spici","spider","spread","spread"，"cheese"，和"butter"替换为"bananas"","squar","square(sidelength","square.cent","square.origin","square.origin.i","square.origin.x","square.sidelength","square的center属性可以通过点运算符（square.center）来访问，这会调用getter来获取属性的值。跟直接返回已经存在的值不同，getter实际上通过计算然后返回一个新的point实例表示square的中心点。如代码所示，它正确返回了中心点(5","square的rect实例，初始值原点是(0","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/barcode_qr_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/barcode_upc_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/computedproperties_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/coordinategraphcomplex_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/coordinategraphmedium_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/coordinategraphsimple_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/staticpropertiesvumeter_2x.png","stack","stack(栈)。一个栈是一系列值域的集合，和array(数组)相似，但其是一个比swift的array类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许，只允许在集合的末端添加新的项（如同push一个新值进栈）。同样的一个栈也只能从末端移除项（如同pop","stack(inout","swaptwovalues例子中，节点类型t是一种类型参数的示例。类型参数指定并命名为一个节点类型，并且紧随在函数名后面，并用一对尖括号括起来（如)。这个尖括号告诉swift那个t是swaptwovalues函数所定义的一个节点类型。因为t是一个节点，swift不会去查找每一个命名为t","t-shirt","t.0","t.1","t.element","t.generatortype.el","tab","tab（horizont","tab（vert","tab）\\t","tab）（u+0009","tab）（u+000b）、换页符（form","tailor","take","taken","tandem","tandem.descript","tandem类也继承了descript","target","task","tast","tasti","tea","teamscor","temperatureinfahrenheit","temporari","temporarya","ten","tenant","teneighti","teneighty.framer","teneighty.interlac","teneighty.nam","teneighty.resolut","teneighty和alsoteneighty被声明为常量(constants)而不是变量。然而你依然可以改变teneighty.framerate和alsoteneighty.framerate,因为这两个常量本身不会改变。它们并不储存这个videomode实例，在后台仅仅是对videomode实例的引用。所以，改变的是被引用的基础videomode的framer","teneighty的framerate属性，我们会发现它正确的显示了基本videomode实例的新帧率，其值为30.0","teneighty的常量，其引用了一个videomode类的新实例。在之前的示例中，这个视频模式(video","teneight和alsoteneight实际上引用的是相同的videomod","terminolog","ternari","terrapin","test","test.area","test.simpledescript","testnumb","text","text</p>"或者"<p","text"还是nil，闭包会返回"<p>som","textrepresent","textrepresentabl","textrepresentable协议含有一个astext","theaceofspad","theaceofspades.descript","theeighti","there’","thing","things.append(\"hello","things.append((3.0","things.append(0","things.append(0.0","things.append(3.14159","things.append(42","things.append(movie(nam","things数组中的每一项的并用switch语句查找每一项的类型。这几种switch","things数组可以被直接遍历,并调用其中元素的astext","thing被当做是textrepresentable类型而不是dice,dicegame,hamster等类型.因此能且仅能调用astext","think","third","those","thought","thousand","three","threedescript","threedoubl","threefeet","threeofspad","threeofspades.simpledescript","threeofspadesdescript","threesourc","threesource作为数据源开实例化一个count","threesource实现了counterdatasourc","threetimest","threetimestable[6]。这句话访问了threetimestable的第六个元素，返回18或者6的3","three的值被用来创建一个doubl","threshold","thresholdlevel","through","through)带标签的语句控制传递语句break","time","timest","timestable(multipli","timestable例子是基于一个固定的数学公式。它并不适合开放写权限来对threetimestable[someindex","timestable结构体中使用只读下标的用法，该结构体用来展示传入整数的n","timestable结构体创建了一个用来表示索引值三倍的实例。数值3作为结构体构造函数入参表示这个值将成为实例成员multipli","tobedoubl","todai","togeth","toggl","togglabl","togglable协议含有toggle函数.根据函数名称推测,toggle可能用于切换或恢复某个属性的状态.mut","togglabl协议时,必须在toggle方法前加上mut","toincrement","toint方法可能会失败，所以它返回一个可选的int，而不是一个int。一个可选的int被写作int?而不是int。问号暗示包含的值是可选，也就是说可能包含int值也可能不包含值。（不能包含其他任何值比如bool值或者string值。只能是int","toint方法来尝试将一个string转换成int","tokyo","toobig","top","top-level","top-level-declar","toraw","toraw和fromraw","tostr","tostring:\"world","total","total.conson","totalstep","totalsteps设置新值的时候，它的willset和didset","totwo","touch","towardszerosourc","towardszerosource实现了counterdatasource协议中的incrementforcount","to那些包含可选成员需求的协议。更多关于如何使用optional特性以及如何访问可选协议成员的指导，例如，当你不确定一个conform","tracker","tracker.advancetolevel(level","trail","trailing-closur","transer","trap","travel","tre","treat","tree","tree）的叶子节点传向根节点。也就是说，var","triagl","triangl","triangle.perimet","triangle.sidelength","triangleandsquar","triangleandsquare(s","triangleandsquare.squar","triangleandsquare.square.sidelength","triangleandsquare.triangle.sidelength","trigger","tristateswitch","tristateswitch.low","true","true)，statements将会被执行，然后转到第3步。如果为假(false)，statements和increment都不会被执行，for","true)，转到第1步。如果为假(false)，do-whil","true)，转到第2步。如果为假(false)，whil","true。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为true，代码运行会继续进行；如果条件判断为fals","true和fals","true，会重复运行一系列语句，直到条件变为fals","true，则会执行大括号内部的代码（stat","true，即allowentry为fals","true，整个表达式就为tru","truncat","try","tuesdai","tulip","tupl","tuple-pattern","tuple-pattern-el","tuple-pattern-element-list","tuple-patterntype-annotationopt","tuple-typ","tuple-type-bodi","tuple-type-body[opt","tuple-type-el","tuple-type-element-list","turn","turnip","turnipsaredelici","two","two-dimension","twothousand","twothousandandon","twothousand类型是uint16，然而常量one类型是uint8。它们不能直接相加，因为它们类型不同。所以要调用uint16(one)来创建一个新的uint16数字并用on","twothre","two’","tyo","type","type(in","type)(译者注:特指结构体和枚举)中的的函数前缀加上mut","type),修改变量的值就相当于修改变量的类型,而swift默认不允许修改类型,因此需要前置mut","type),可以方便的修改实例及其属性的值而无需改变类型;而结构体和枚举中的成员均为值类型(valu","type)。你可以在声明属性或者变量时，在前面加上关键字unown","type)的上下文(context)中，隐式成员表达式是访问某个type的memb","type-annot","type-cast","type-casting-oper","type-casting-pattern","type-identifi","type-identifier­:­protocol-composition-typ","type-identifier­:­type-identifi","type-identifier­==­type-identifi","type-inheritance-claus","type-inheritance-list","type-nam","type-name­:­protocol-composition-typ","type-name­:­type-identifi","type-saf","type.protocol","type.self","type.typ","typealia","typealias-assign","typealias-declar","typealias-head","typealias-nam","types(章节信息url","types中知道结构体有默认的成员构造函数，所以你可以用默认的initializer去初始化新的常量theaceofspad","types）——比如表示数字、字符和字符串——实际上就是命名型类型，swift","types）使用函数类型（us","types）函数类型作为参数类型（funct","types）函数类型作为返回类型（funct","types）嵌套函数（nest","types，如int、character)外，你可以使用任何类型的值，包括浮点数、字符串、元组、自定义类的实例和可选(optional)类型，甚至是枚举类型中的成员值和指定的范围(range)等。关于在switch语句中使用这些类型，请参考控制流一章的switch","type’","type。协议类型的元类型——并不是运行时适配该协议的具体类型——是该协议名字紧跟.protocol。比如，类someclass的元类型就是someclass.type，协议someprotocol的元类型就是someprotocal.protocol","type在声明时候所定义(declar","type是int","type的名字(当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的typ","type）。，即使是这个方法本是没有定义返回值，你也可以使用if语句来检查是否能成功调用printnumberofrooms方法：如果方法通过可选链调用成功，printnumberofrooms的隐式返回值将会是void，如果没有成功，将返回nil","t分别代表tnt和string","t则是跟这些type的公共supertype最接近的type.(closest","t和u遵守generator协议，同时要求它们的关联类型等同，可以这样来表达：<t","t定义了一个名为“某种类型t”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“t”。在这种情况下，t","t就是数组中元素的type","t来表示）来代替实际类型名（如int、string或double）。节点类型名并不是表示t必须是任何类型，但是其规定a和b必须是同一类型的t，而不管t表示任何类型。只有swaptwovalues函数在每次调用时所传入的实际类型决定了t","t被用作append方法的item参数和下标的返回类型。swift因此可以推断出被用作这个特定容器的itemtype的t","t，u，v，keytype，valuetyp","t，是@noreturn","t，有一个需要t必须是someclass子类的类型约束；第二个类型参数u，有一个需要u必须遵循someprotocol","u","u+000a","u+000d","u+0024","u+00a8","u+00aa","u+00ad","u+00af","u+00b2–u+00b5","u+00b7–u+00ba","u+00bc–u+00b","u+00c0–u+00d6","u+00d8–u+00f6","u+00f8–u+00ff","u+0100–u+02ff","u+0300–u+036f","u+0370–u+167f","u+10000–u+1fffd","u+1681–u+180d","u+180f–u+1dbf","u+1dc0–u+1dff","u+1e00–u+1fff","u+1f436","u+1f496","u+20000–u+2fffd","u+200b–u+200d","u+202a–u+202","u+203f–u+2040","u+2054","u+2060–u+206f","u+2070–u+20cf","u+20d0–u+20ff","u+2100–u+218f","u+2460–u+24ff","u+2665","u+2776–u+2793","u+2c00–u+2dff","u+2e80–u+2fff","u+30000–u+3fffd","u+3004–u+3007","u+3021–u+302f","u+3031–u+303f","u+3040–u+d7ff","u+40000–u+4fffd","u+50000–u+5fffd","u+60000–u+6fffd","u+70000–u+7fffd","u+80000–u+8fffd","u+90000–u+9fffd","u+a0000–u+afffd","u+b0000–u+bfffd","u+c0000–u+cfffd","u+d0000–u+dfffd","u+d83d","u+e0000–u+efffd","u+f900–u+fd3d","u+fd40–u+fdcf","u+fdf0–u+fe1f","u+fe20–u+fe2f","u+fe30–u+fe44","u+fe47–u+fffd","u.element>","u.generatortype.el","u0001f496","u2665","uinavigationcontrol","uint","uint16","uint16(on","uint16有一个构造器，可以接受一个uint8类型的值，所以这个构造器可以用现有的uint8来创建一个新的uint16。注意，你并不能传入任意类型的值，只能传入uint16","uint16，可以进行相加。目标常量twothousandandone的类型被推测为uint16，因为它是两个uint16","uint32","uint32的命名为pink的常量来存储层叠样式表css中粉色的颜色值，css颜色#cc6699在swift用十六进制0xcc6699来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(cc)，绿(66)，蓝(99","uint8","uint8.max","uint8.min","uint8是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值00001111(前4位为0，后4位为1)，它的十进制值为15","uint8的最小值0","uint8的最小值是0(二进制为00000000)。使用&-进行溢出减1，就会得到二进制的11111111即十进制的255","uint，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用int，即使你要存储的值已知是非负的。统一使用int","uitableviewdeleg","unabl","unari","uncertainti","uncom","undefinedundefin","underflow","underflow值的下溢出divis","underli","unicod","unicodescalar","unicodescalarview","unicodescalar拥有一个值属性，可以返回对应的21位数值，用uint32","unicodescalar是21","union-style-enum","union-style-enum-cas","union-style-enum-case-claus","union-style-enum-case-list","union-style-enum-memb","unions）和变体（vari","unions），或者变体（vari","unions），标签联合（tag","unlik","unlock","unlocklevel(level","unnnnnnnn，其中nnnnnnnn","unnnn，其中nnnn","uno","unown","unowned(saf","unowned(unsaf","unshar","unshare方法来确定数组引用的唯一性。(当数组赋给常量时，不能调用unshar","unshare方法调用后再修改b中第一个元素的值，这三个数组(a,b,c","unshare方法，而不是copy方法。unshare方法仅会在确有必要时才会创建数组拷贝。copi","unsign","unusu","unusualmenageri","unwrap","unwrappedc","unwrappedc.property.performact","up","upc-a","upca(int","upca(let","upca(numbersystem","updatevalue(forkey:)函数会返回包含一个字典值类型的可选值。举例来说：对于存储string值的字典，这个函数会返回一个str","updatevalue(forkey:)方法可以设置或者更新特定键对应的值。就像上面所示的示例，updatevalue(forkei","upper","uppercamelcas","uppercas","uppercasestring和lowercasestr","upward","uranu","us","uss","utf-16","utf-16(以16","utf-8","utf-8(以8","utf16","utf16count","utf16view","utf16属性来访问它的utf-16","utf8","utf8view","utf8属性来访问它的utf-8","v","valid","valu","value),当其不可访问时,?之后语句不会执行,并返回nil","value)，检查另一个字典中所对应的值，来证明ages字典确实是被拷贝了。如果在copiedages字典中将peter的值设为24，那么ages字典仍然会返回修改前的值23","value-bind","value-binding-pattern","values(first","values）函数参数名（funct","values）原始值（raw","values）可变参数（variad","values）多重输入参数（multipl","values）多重返回值函数（funct","values）默认值参数的外部参数名（extern","valuetofind","valuetofind”。不是所有的swift中的类型都可以用等式符(==)进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么swift没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型t","valuetyp","valuetype>定义,其中keytype是字典中键的数据类型，valuetyp","value的typ","value）元组。下面的例子中，字典的键(kei","value）都关联独特的键（kei","value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加&","var","variabl","variable-declar","variable-declaration-head","variable-nam","variablestr","variad","var关键字定义计算属性，包括只读计算属性，因为他们的值不是固定的。let","var定义），也可以是常量存储属性（用关键字let","var或者let","vector","vector.i","vector.x","vector2d","vector2d(1.0","vector2d(x","vector2d对象是否有相等的值，相等的概念就是他们有相同的x值和相同的i","vector2d类型提供了单目减运算-a，@prefix","vector2d类型的参数，返回值也是vector2d类型。需要定义和实现一个中置运算的时候，在关键字func","vector2d结构的成员方法，所以任意两个vector2d","vector2d，单目减运算将其x和i","vectortoadd","veget","vegetablecom","vehicl","vehicle的一个新的子类，叫car，它重写了从vehicle类继承来的'description'","vehicle的基类。这个基类声明了两个对所有车辆都通用的属性（numberofwheels和maxpassengers）。这些属性在description方法中使用，这个方法返回一个str","vehicle类中maxpassengers的默认值对自行车来说已经是正确的，因此在bicycle的初始化器中并没有改变它。而numberofwheels原来的值对自行车来说是不正确的，因此在初始化器中将它更改为2","vehicle类定义了初始化器（initi","vehicle类的初始化器为任意的一辆车设置一些初始化属性值（numberofwheel","vendcoins(var","vendcoins方法在bank分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，bank返回一个比请求时小的数字(如果没有硬币留在bank中就返回0)。vendcoins方法声明numberofcoinstovend为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。vendcoin","venu","veri","verona","versa","version","vga","vic","vice","videomod","videomode中resolution属性的width","videomode的类，用来描述一个视频显示器的特定模式。这个类包含了四个储存属性变量。第一个是分辨率，它被初始化为一个新的resolution结构体的实例，具有resolution的属性类型。新videomode实例同时还会初始化其它三个属性，它们分别是，初始值为false(意为“non-interlac","video”)的inteflaced，回放帧率初始值为0.0的framerate和值为可选string的name。name属性会被自动赋予一个默认值nil，意为“没有nam","view","void","void。在swift中，void","void是空元组类型()的别名。如果括号内只有一个元素，那么该类型就是括号内元素的类型。比如，(int)的类型是int而不是(int","void（参见funct","void？，而不是void，因为当通过可选链调用方法时返回值总是自判断类型（opt","volum","vowel","vowel代替character.kind.vowel","vumet","w","wai","want","warm","watch","water","watercress","we'r","weak","weak或者unowned关键字和实例的引用(如self或someinst","wear","web","wei","welcom","welcomemessag","welcomemessage变量添加了类型标注，表示这个变量可以存储str","well","west","wheel","whenev","wherea","where­requirement-list","where语句。where语句由关键字wher","where语句中的要求用于指明该类型形参继承自某个类或遵守某个协议或协议的一部分。尽管where语句有助于表达类型形参上的简单约束（如t","where语句作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置wher","where语句的一部分，写在关键字wher","where，只在冒号后面写接口或者类名。<t","whether","while-condit","while-stat","whiledo-while条件语句ifswitch不存在隐式的贯穿(fallthrough","while循环体中调用break和continu","while循环体和switch方法块来实现游戏的逻辑。while循环体有一个标签名gameloop","while循环体的条件判断语句是whil","while循环体的语法，同样的规则适用于所有的循环体和switch","whisper","white","whitespac","whose","wide","width","width=\"169","width=\"243","width=\"252","width=\"288","width=\"289","width=\"388","widthlabel","width属性和height属性，两者均为doubl","wildcard","wildcard-express","wildcard-pattern","wildcard-patterntype-annotationopt","willoverflow","willoverflow用int8所能承载的最大值255(二进制11111111)，然后用&+加1。然后uint8就无法表达这个新值的二进制了，也就导致了这个新值上溢出了，大家可以看下图。溢出后，新值在uint8的承载范围内的那部分是00000000，也就是0","willset","willset(newtotalstep","willset-claus","willset-didset-block","willset和didset","willset和didset的实际例子，其中定义了一个名为stepcount","willset或didset实现是不恰当。此外还要注意，你不可以同时提供重写的setter和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的setter，那么你在sett","willset监视器会将新的属性值作为固定参数传入，在willset的实现代码中可以为这个参数指定一个名称，如果不指定则参数仍然可用，这时使用默认名称newvalu","willset监视器将表示新值的参数自定义为newtotalstep","willunderflow","win","wincoins(coin","wiseword","wishhappybirthday(birthdayperson","wishhappybirthday(celebr","wishhappybirthday函数的形参celebrator的类型为protocol<named,aged>","within","withjoin","without","won","word","work","world","world"","world(item","result","result(str","result(sunris","return","returnfifteen","rh","rhsitem","sandwich","score","secondforloop","see","self","self.nam","self.sidelength","self被用来区别实例变量。当你创建实例的时候，像传入函数参数一样给类传入构造器的参数。每个属性都需要赋值——无论是通过声明（就像numberofsides）还是通过构造器（就像nam","sequenc","serverrespons","serverresponse.error(\"out","serverresponse.result(\"6:00","serverresponse和switch","set","setter","seven","shape","shape.numberofsid","shape.simpledescript","shapedescript","shape类缺少了一些重要的东西：一个构造函数来初始化类实例。使用init","shinyzhu","shoppinglist","shoppinglist[1","side","sidelength","simpl","simpleclass","simpledescript","simplestructur","simplestructure时候mutating关键字用来标记一个会修改结构体的方法。simpleclass","six","size","some(100","some(t","sort([1","soup","spade","spici","squar","square(sidelength","square.sidelength","standard","string","string(self.toraw","string(width","struct","structur","success","suit","suit.heart","suit.simpledescript","suit添加一个color方法，对spades和clubs返回“black”，对hearts和diamonds返回“r","sum","sumof","sumof(42","sumof(numb","sunris","sunset","super.init(nam","swift","switch","switch中匹配到的子句之后，程序会退出switch语句，并不会继续向下运行，所以不需要在每个子句结尾写break","t","t.generatortype.el","tast","tea","teamscor","ten","test","test.area","test.simpledescript","three","threedescript","threeofspad","threeofspades.simpledescript","threeofspadesdescript","time","todai","toraw和fromraw","triagl","triangl","triangle.perimet","triangle.sidelength","triangleandsquar","triangleandsquare(s","triangleandsquare.squar","triangleandsquare.square.sidelength","triangleandsquare.triangle.sidelength","true","tuesdai","tulip","two","type","u","u.generatortype.el","uncom","undefinedundefin","valu","var","veget","vegetablecom","veri","water","watercress","where，只在冒号后面写接口或者类名。<t","width","widthlabel","willset","willset和didset","world","x","x.hassuffix(\"pepp","xcode","y"],"chapter1/chapter1.html#gitbook_6470":["swift","undefinedundefin"],"chapter2/13_Inheritance.html#gitbook_6471":["0","0.0","0和maxpasseng","1","10.0","2","35.0","4","40.0","5","60.0","automat","automatic.descript","automatic.spe","automaticcar","automaticcar的speed属性，属性的didset观察器就会自动地设置gear属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位gear的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4","automaticcar，它是car的子类。automaticcar表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。automaticcar也提供了定制的descript","base","bicycl","bicycle.descript","bicycle不仅可以继承vehicle的属性，还可以继承它的方法。如果你创建了一个bicycle类的实例，你就可以调用它继承来的descript","bicycle是vehicle的子类，vehicle是bicycle的超类。新的bicycle类自动获得vehicl","bicycle的一个子类：双人自行车（tandem）。tandem从bicycle继承了两个属性，而这两个属性是bicycle从vehicle继承而来的。tandem","bicycle类定义了一个构造器来设置它定制的特性（自行车只有2个轮子）。bicycle的构造器调用了它父类vehicl","bicycle，它继承了vehicl","calss","car","car.descript","car中的description方法并非完全自定义，而是通过super.description使用了超类vehicle中的descript","car声明了一个新的存储型属性speed，它是double类型的，默认值是0.0，表示“时速是0英里”。car有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4","car的新实例，并打印descript","car重写了继承来的description方法，它的声明与vehicle中的description方法一致，声明前面加上了overrid","class","class前添加@final特性（@fin","class）子类生成（subclassing）重写（overriding）访问超类的方法，属性及附属脚本重写方法重写属性重写属性的getters和setters重写属性观察器（properti","descript","didset","doubl","final","final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@fin","func","gear","getter","getters和sett","getter和sett","hawstein","inherit","inheritance）定义一个基类（bas","inherit）另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫子类（subclass），被继承类叫超类（或父类，superclass","init","instanc","int","int(spe","limitedcar","limitedcar.descript","limitedcar.spe","maxpasseng","maxpassengers和numberofwheels属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述bicycl","menlongsheng","method），实例属性（inst","method），类方法（class","min(newvalu","mph","name=\"defining_a_base_class\">解决实例之间的循环强引用解决实例之间的循环强引用弱引用无主引用hello","paragraph","paragraph变量为nil，打破它持有的htmlelement实例的强引用，htmlel","paragraph变量定义为可选htmlelement，因此我们可以赋值nil","person","person(nam","person?的变量，用来按照代码片段中的顺序，为新的person实例建立多个引用。由于这些变量是被定义为可选类型（person?，而不是person），它们的值会被自动初始化为nil，目前还不会引用到person","person和apart","person和apartment实例并将类实例赋值给john和number73","person和apartment的例子一致，但是有一个重要的区别。这一次，apartment的ten","person和apartment的例子展示了两个属性的值都允许为nil","person实例依然保持对apartment实例的强引用，但是apartment实例只是对person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向person","person实例有一个类型为string，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apart","person实例现在有了一个指向apartment实例的强引用，而apartment实例也有了一个指向person实例的强引用。因此，当你断开john和number73","person实例的引用数量，并且会在person","person实例，这也意味着你不再使用这个person","person类开始，并定义了一个叫nam","person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。person","person类的新实例被赋值给了reference1变量，所以reference1到person类的新实例之间建立了一个强引用。正是因为这个强引用，arc","person类的构造函数的时候，"john","print","println(\"\\(country.name)'","println(\"\\(nam","println(\"apart","println(\"card","println(paragraph!.ashtml","prints\"hello","quot","refer","reference1","reference2","reference3","reference）和无主引用（unown","return","self","self.capitalc","self.countri","self.custom","self.nam","self.name)>\\(text)(arrai","equatable类型都可以安全的使用在findindex函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个equat","equatable，也就意味着“任何t类型都遵循equat","equival","extens","fals","findindex([\"mik","findindex([3.14159","findindex(arrai","findindex中这个单个类型参数写做：t","findindex函数现在则可以成功的编译过，并且作用于任何遵循equatable的类型，如double或str","findindex，用某个类型t","findstringindex","findstringindex(arrai","findstringindex(str","findstringindex的泛型版本findindex。请注意这个函数仍然返回int","findstringindex的非泛型函数，该函数功能是去查找包含一给定string值的数组。若查找到匹配的字符串，findstringindex函数返回该字符串在数组中的索引值（int），反之则返回nil","for-in循环和半闭区间操作（..）来迭代somecontainer中的所有元素。对于每个元素，函数检查是否somecontainer中的元素不等于对应的anothercontainer中的元素，如果这两个元素不等，则这两个容器不匹配，返回fals","for—that","foundindex","fromthetop","func","function","goe","hello","here","implement","in-out）参数来交换a和b的值，请参考[写入读出参数][1","index","inform","inout","int","intstack","intstack指定了container的实现，适用的itemtype被用作int类型。对于这个contain","intstack类型只能用于int值，不过，其对于定义一个泛型stack","intstack类型实现了container协议的所有三个要求，在intstack","intstack类型的非泛型版本，适用于遵循contain","int数组，也可创建一个str","int索引值下标可以检索到每一个item","int这一行，一切仍旧可以工作，因为它清楚的知道itemtyp","int，将抽象的itemtype类型转换为具体的int","item","items.append(item","items.count","items.removelast","items[i","items的属性，使用空的t","itemtyp","itemtype。th","itemtype的t","item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循contain","item的push方法，该参数必须是t","left","lifedim","llama","malcolm","match","mutat","name=\"associated_types\">(somet","somestr","someu","stack","stack(inout","swaptwovalues例子中，占位类型t是一种类型参数的示例。类型参数指定并命名为一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（如$0、$1、$2`。例如，class`class`。反引号不属于标识符的一部分，`x`(x","comparable等同于t","comparable表示任何用于替代类型形参t的类型实参必须满足compar","comparable，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，<t","conformance-requir","constrain","dictionary泛型实参语句泛型形参语句泛型形参语句where语句":{"docs":{},"$":{"0":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"、":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"$":{"1":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"、":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"$":{"2":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"。":{"docs":{},"反":{"docs":{},"引":{"docs":{},"号":{"docs":{},"不":{"docs":{},"属":{"docs":{},"于":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"<":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},">":{"docs":{},"`":{"docs":{},"x":{"docs":{},"`":{"docs":{},"<":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},">":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"用":{"docs":{},"于":{"docs":{},"替":{"docs":{},"代":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"等":{"docs":{},"等":{"docs":{},"）":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"及":{"docs":{},"其":{"docs":{},"关":{"docs":{},"联":{"docs":{},"约":{"docs":{},"束":{"docs":{},"提":{"docs":{},"供":{"docs":{},"更":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"约":{"docs":{},"束":{"docs":{},"。":{"docs":{},"如":{"docs":{},"，":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}},"s":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"不":{"docs":{},"是":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"等":{"docs":{},"于":{"0":{"docs":{},"，":{"1":{"docs":{},"，":{"2":{"docs":{},"和":{"3":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"这":{"docs":{},"些":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"在":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}},"u":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":2.004878048780488}}}}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396}}}}}}},"l":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":5.00437636761488},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":10.005167958656331},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"列":{"docs":{},"表":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"或":{"docs":{},"序":{"docs":{},"列":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.007619047619047619}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.11891891891891893},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588}},"s":{"docs":{},"个":{"docs":{},"数":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"存":{"docs":{},"储":{"docs":{},"，":{"docs":{},"将":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"和":{"docs":{},"数":{"docs":{},"组":{"docs":{},"每":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},"(":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}},"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"三":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"：":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"、":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"和":{"docs":{},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"0":{"docs":{},".":{"0":{"docs":{},"到":{"1":{"docs":{},".":{"0":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"e":{"docs":{},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}}}}}}}},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"强":{"docs":{},"制":{"docs":{},"显":{"docs":{},"性":{"docs":{},"复":{"docs":{},"制":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"对":{"docs":{},"数":{"docs":{},"组":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"docs":{},"浅":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.08387096774193549}},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.025806451612903226}}}}}},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.025806451612903226}}}}}}}}}}}},"兼":{"docs":{},"容":{"docs":{},"性":{"docs":{},"的":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.007905138339920948}},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.013011152416356878}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"在":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"给":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"后":{"docs":{},"，":{"docs":{},"整":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"程":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"代":{"docs":{},"表":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"后":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"就":{"docs":{},"能":{"docs":{},"引":{"docs":{},"用":{"docs":{},"并":{"docs":{},"传":{"docs":{},"递":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"能":{"docs":{},"将":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}}}}}}}}}},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"并":{"docs":{},"非":{"docs":{},"完":{"docs":{},"全":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"超":{"docs":{},"类":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"0":{"docs":{},".":{"0":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"docs":{},"时":{"docs":{},"速":{"docs":{},"是":{"0":{"docs":{},"英":{"docs":{},"里":{"docs":{},"”":{"docs":{},"。":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"有":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"乘":{"docs":{},"客":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"数":{"docs":{},"量":{"docs":{},"设":{"docs":{},"为":{"5":{"docs":{},"，":{"docs":{},"轮":{"docs":{},"子":{"docs":{},"数":{"docs":{},"量":{"docs":{},"设":{"docs":{},"为":{"4":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"打":{"docs":{},"印":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}},"重":{"docs":{},"写":{"docs":{},"了":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"与":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.024},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.07523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.07333333333333333},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0200445434298441},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.03937007874015748},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.017241379310344827},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.00842358604091456},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.01284796573875803},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1379310344827587},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.014005602240896359}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"s":{"docs":{},"里":{"docs":{},"用":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"会":{"docs":{},"终":{"docs":{},"止":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"执":{"docs":{},"行":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"在":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}}}}},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"层":{"docs":{},"次":{"docs":{},"作":{"docs":{},"为":{"docs":{},"例":{"docs":{},"子":{"docs":{},"检":{"docs":{},"查":{"docs":{},"类":{"docs":{},"型":{"docs":{},"向":{"docs":{},"下":{"docs":{},"转":{"docs":{},"型":{"docs":{},"（":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"f":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{},"（":{"docs":{},"不":{"docs":{},"过":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23498238195912613},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3477920130843669}}}},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"b":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}},"'":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}}},"s":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}},"。":{"docs":{},"它":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"：":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},":":{"docs":{},")":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"k":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889}}},"属":{"docs":{},"性":{"docs":{},"之":{"docs":{},"后":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"1":{"5":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"x":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"一":{"docs":{},"个":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"原":{"docs":{},"点":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"调":{"docs":{},"用":{"docs":{},"该":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"自":{"docs":{},"动":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588}},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415}},"实":{"docs":{},"例":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"会":{"docs":{},"被":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"将":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"棋":{"docs":{},"盘":{"docs":{},"中":{"docs":{},"每":{"docs":{},"个":{"docs":{},"格":{"docs":{},"子":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"，":{"docs":{},"将":{"docs":{},"这":{"docs":{},"些":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"保":{"docs":{},"存":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"临":{"docs":{},"时":{"docs":{},"数":{"docs":{},"组":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"中":{"docs":{},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"构":{"docs":{},"建":{"docs":{},"完":{"docs":{},"成":{"docs":{},"时":{"docs":{},"将":{"docs":{},"此":{"docs":{},"数":{"docs":{},"组":{"docs":{},"作":{"docs":{},"为":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"返":{"docs":{},"回":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"保":{"docs":{},"存":{"docs":{},"到":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"中":{"docs":{},"，":{"docs":{},"并":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"s":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.8775889537971323},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.006666666666666667},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593}},"e":{"docs":{},"r":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777}}},"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}},"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}}}}}}},"（":{"docs":{},"字":{"docs":{},"符":{"docs":{},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"的":{"docs":{},"可":{"docs":{},"能":{"docs":{},"性":{"docs":{},"都":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"出":{"docs":{},"来":{"docs":{},"是":{"docs":{},"不":{"docs":{},"现":{"docs":{},"实":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"来":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"上":{"docs":{},"面":{"docs":{},"没":{"docs":{},"有":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"这":{"docs":{},"个":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"执":{"docs":{},"行":{"docs":{},"任":{"docs":{},"何":{"docs":{},"动":{"docs":{},"作":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"只":{"docs":{},"写":{"docs":{},"了":{"docs":{},"一":{"docs":{},"条":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"落":{"docs":{},"入":{"docs":{},"到":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"后":{"docs":{},"，":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"就":{"docs":{},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"该":{"docs":{},"分":{"docs":{},"支":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"继":{"docs":{},"续":{"docs":{},"向":{"docs":{},"下":{"docs":{},"，":{"docs":{},"开":{"docs":{},"始":{"docs":{},"执":{"docs":{},"行":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364}}}}}}}},"值":{"docs":{},"或":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"值":{"docs":{},"，":{"docs":{},"相":{"docs":{},"加":{"docs":{},"会":{"docs":{},"生":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"是":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"即":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"新":{"docs":{},"的":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"\\":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}},"docs":{}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":5.003184713375796}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"可":{"docs":{},"以":{"docs":{},"请":{"docs":{},"求":{"docs":{},"和":{"docs":{},"调":{"docs":{},"用":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"方":{"docs":{},"法":{"docs":{},"及":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"性":{"docs":{},"体":{"docs":{},"现":{"docs":{},"于":{"docs":{},"请":{"docs":{},"求":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"当":{"docs":{},"前":{"docs":{},"可":{"docs":{},"能":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"有":{"docs":{},"值":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"调":{"docs":{},"用":{"docs":{},"就":{"docs":{},"会":{"docs":{},"成":{"docs":{},"功":{"docs":{},"；":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"选":{"docs":{},"择":{"docs":{},"的":{"docs":{},"目":{"docs":{},"标":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"种":{"docs":{},"调":{"docs":{},"用":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"多":{"docs":{},"次":{"docs":{},"请":{"docs":{},"求":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"链":{"docs":{},"接":{"docs":{},"在":{"docs":{},"一":{"docs":{},"起":{"docs":{},"形":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"链":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"节":{"docs":{},"点":{"docs":{},"为":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.011428571428571429},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.040293040293040296},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.015555555555555555},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.015306122448979591},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.012867647058823529},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.02095238095238095},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.01684717208182912},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.011142061281337047},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.012845849802371542},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.007494646680942184},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"前":{"docs":{},"添":{"docs":{},"加":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"（":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}},"）":{"docs":{},"子":{"docs":{},"类":{"docs":{},"生":{"docs":{},"成":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"重":{"docs":{},"写":{"docs":{},"（":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"访":{"docs":{},"问":{"docs":{},"超":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"及":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"重":{"docs":{},"写":{"docs":{},"方":{"docs":{},"法":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"重":{"docs":{},"写":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":3.333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"这":{"docs":{},"些":{"docs":{},"目":{"docs":{},"标":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"访":{"docs":{},"问":{"docs":{},"对":{"docs":{},"象":{"docs":{},"、":{"docs":{},"集":{"docs":{},"合":{"docs":{},"或":{"docs":{},"序":{"docs":{},"列":{"docs":{},"的":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"再":{"docs":{},"调":{"docs":{},"用":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"和":{"docs":{},"访":{"docs":{},"问":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"举":{"docs":{},"例":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"用":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"访":{"docs":{},"问":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"它":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{},"类":{"docs":{},"成":{"docs":{},"员":{"docs":{},"；":{"docs":{},"用":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"或":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"实":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"为":{"docs":{},"类":{"docs":{},"成":{"docs":{},"员":{"docs":{},"；":{"docs":{},"当":{"docs":{},"协":{"docs":{},"议":{"docs":{},"用":{"docs":{},"于":{"docs":{},"被":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"时":{"docs":{},"，":{"docs":{},"则":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"类":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"用":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"类":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"变":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"类":{"docs":{},"和":{"docs":{},"静":{"docs":{},"态":{"docs":{},"变":{"docs":{},"量":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"用":{"docs":{},"写":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"；":{"docs":{},"用":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"实":{"docs":{},"现":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"写":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}},"属":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"整":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"任":{"docs":{},"意":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"标":{"docs":{},"记":{"docs":{},"有":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"协":{"docs":{},"议":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"必":{"docs":{},"需":{"docs":{},"的":{"docs":{},"静":{"docs":{},"态":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"执":{"docs":{},"行":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"类":{"docs":{},"也":{"docs":{},"用":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"、":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"、":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"、":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"、":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"、":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"、":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.023880597014925373},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.005928853754940711},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"值":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}},"闭":{"docs":{},"包":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"可":{"docs":{},"执":{"docs":{},"行":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"（":{"docs":{},"跟":{"docs":{},"方":{"docs":{},"法":{"docs":{},"主":{"docs":{},"体":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"缩":{"docs":{},"写":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"u":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}},"u":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}},"值":{"docs":{},"大":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"之":{"docs":{},"前":{"docs":{},"任":{"docs":{},"意":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"新":{"docs":{},"值":{"docs":{},"保":{"docs":{},"存":{"docs":{},"在":{"docs":{},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"值":{"docs":{},"大":{"docs":{},"于":{"docs":{},"允":{"docs":{},"许":{"docs":{},"的":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"限":{"docs":{},"定":{"docs":{},"为":{"docs":{},"阈":{"docs":{},"值":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"在":{"docs":{},"更":{"docs":{},"新":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"之":{"docs":{},"前":{"docs":{},"检":{"docs":{},"查":{"docs":{},"所":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"新":{"docs":{},"等":{"docs":{},"级":{"docs":{},"是":{"docs":{},"否":{"docs":{},"已":{"docs":{},"经":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"。":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"以":{"docs":{},"指":{"docs":{},"示":{"docs":{},"是":{"docs":{},"否":{"docs":{},"能":{"docs":{},"够":{"docs":{},"设":{"docs":{},"置":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.009696969696969697}}}}}},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}}}}}}}}}}},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}},"t":{"docs":{},"i":{"docs":{},"z":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"b":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"三":{"docs":{},"维":{"docs":{},"空":{"docs":{},"间":{"docs":{},"的":{"docs":{},"立":{"docs":{},"方":{"docs":{},"体":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"、":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"只":{"docs":{},"读":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"用":{"docs":{},"来":{"docs":{},"返":{"docs":{},"回":{"docs":{},"立":{"docs":{},"方":{"docs":{},"体":{"docs":{},"的":{"docs":{},"体":{"docs":{},"积":{"docs":{},"。":{"docs":{},"设":{"docs":{},"置":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"毫":{"docs":{},"无":{"docs":{},"意":{"docs":{},"义":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"通":{"docs":{},"过":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"、":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{},"就":{"docs":{},"能":{"docs":{},"算":{"docs":{},"出":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"c":{"docs":{},"u":{"docs":{},"b":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.017142857142857144},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}},"和":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"与":{"docs":{},"前":{"docs":{},"面":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"关":{"docs":{},"系":{"docs":{},"截":{"docs":{},"然":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"据":{"docs":{},"模":{"docs":{},"型":{"docs":{},"中":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"可":{"docs":{},"能":{"docs":{},"有":{"docs":{},"或":{"docs":{},"者":{"docs":{},"没":{"docs":{},"有":{"docs":{},"信":{"docs":{},"用":{"docs":{},"卡":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"一":{"docs":{},"张":{"docs":{},"信":{"docs":{},"用":{"docs":{},"卡":{"docs":{},"总":{"docs":{},"是":{"docs":{},"关":{"docs":{},"联":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"客":{"docs":{},"户":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"种":{"docs":{},"关":{"docs":{},"系":{"docs":{},"，":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"类":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"允":{"docs":{},"许":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"而":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"持":{"docs":{},"有":{"docs":{},"对":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"持":{"docs":{},"有":{"docs":{},"对":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"了":{"docs":{},"。":{"docs":{},"其":{"docs":{},"后":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"变":{"docs":{},"量":{"docs":{},"持":{"docs":{},"有":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"用":{"docs":{},"它":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"新":{"docs":{},"创":{"docs":{},"建":{"docs":{},"的":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"客":{"docs":{},"户":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}}}},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"属":{"docs":{},"性":{"docs":{},"确":{"docs":{},"已":{"docs":{},"改":{"docs":{},"为":{"docs":{},"了":{"2":{"0":{"4":{"8":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"docs":{},"之":{"docs":{},"前":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"h":{"docs":{},"d":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"其":{"docs":{},"实":{"docs":{},"是":{"docs":{},"h":{"docs":{},"d":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"副":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"h":{"docs":{},"d":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"h":{"docs":{},"d":{"docs":{},"和":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"有":{"docs":{},"着":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"宽":{"docs":{},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},")":{"docs":{},"和":{"docs":{},"高":{"docs":{},"(":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619}},"z":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"y":{"docs":{},"!":{"docs":{},"）":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"，":{"docs":{},"将":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"显":{"docs":{},"示":{"docs":{},"展":{"docs":{},"开":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"这":{"docs":{},"表":{"docs":{},"示":{"docs":{},"像":{"docs":{},"其":{"docs":{},"他":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"将":{"docs":{},"实":{"docs":{},"例":{"docs":{},"保":{"docs":{},"存":{"docs":{},"为":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}},",":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},",":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"基":{"docs":{},"类":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"前":{"docs":{},"者":{"docs":{},"把":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"写":{"docs":{},"为":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"言":{"docs":{},"中":{"docs":{},"的":{"docs":{},"指":{"docs":{},"针":{"docs":{},"类":{"docs":{},"似":{"docs":{},"，":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"并":{"docs":{},"不":{"docs":{},"直":{"docs":{},"接":{"docs":{},"指":{"docs":{},"向":{"docs":{},"内":{"docs":{},"存":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"地":{"docs":{},"址":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"也":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"星":{"docs":{},"号":{"docs":{},"(":{"docs":{},"*":{"docs":{},")":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"你":{"docs":{},"在":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"不":{"docs":{},"可":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"。":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"行":{"docs":{},"为":{"docs":{},"会":{"docs":{},"被":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"并":{"docs":{},"报":{"docs":{},"告":{"docs":{},"为":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"你":{"docs":{},"是":{"docs":{},"故":{"docs":{},"意":{"docs":{},"的":{"docs":{},"？":{"docs":{},"好":{"docs":{},"吧":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"为":{"docs":{},"你":{"docs":{},"准":{"docs":{},"备":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"套":{"docs":{},"默":{"docs":{},"认":{"docs":{},"允":{"docs":{},"许":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"如":{"docs":{},"可":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"加":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"+":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"允":{"docs":{},"许":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"的":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"都":{"docs":{},"是":{"docs":{},"以":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}},"/":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"等":{"docs":{},"效":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"从":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{},"而":{"docs":{},"来":{"docs":{},"的":{"docs":{},"新":{"docs":{},"协":{"docs":{},"议":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}},"f":{"docs":{},"(":{"7":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}},"?":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}}}}}}}}}}}}}}},"d":{"1":{"2":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"docs":{}},"6":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}},"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"1":{"0":{"2":{"2":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}}},"v":{"docs":{},"e":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}}}}}}}},"t":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},".":{"docs":{},"t":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112}},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}},"e":{"docs":{},"r":{"docs":{},"也":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"中":{"docs":{},"导":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"当":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"时":{"docs":{},"，":{"docs":{},"没":{"docs":{},"必":{"docs":{},"要":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"更":{"docs":{},"明":{"docs":{},"智":{"docs":{},"的":{"docs":{},"是":{"docs":{},"当":{"docs":{},"用":{"docs":{},"到":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"从":{"docs":{},"文":{"docs":{},"件":{"docs":{},"导":{"docs":{},"入":{"docs":{},"数":{"docs":{},"据":{"docs":{},"，":{"docs":{},"该":{"docs":{},"功":{"docs":{},"能":{"docs":{},"由":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"提":{"docs":{},"供":{"docs":{},"，":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"没":{"docs":{},"有":{"docs":{},"写":{"docs":{},"出":{"docs":{},"全":{"docs":{},"部":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"能":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"后":{"docs":{},"边":{"docs":{},"加":{"docs":{},"上":{"docs":{},"了":{"docs":{},"?":{"docs":{},"标":{"docs":{},"记":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"只":{"docs":{},"在":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"非":{"docs":{},"空":{"docs":{},"时":{"docs":{},"才":{"docs":{},"去":{"docs":{},"调":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"也":{"docs":{},"无":{"docs":{},"法":{"docs":{},"保":{"docs":{},"证":{"docs":{},"其":{"docs":{},"是":{"docs":{},"否":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.008571428571428572},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23619450317124735},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}},"）":{"docs":{},"分":{"docs":{},"支":{"docs":{},"满":{"docs":{},"足":{"docs":{},"该":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"分":{"docs":{},"支":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"i":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.017142857142857144},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":10.006451612903225},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.02857142857142857},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}},"来":{"docs":{},"标":{"docs":{},"示":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.015384615384615385},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.005479452054794521}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.05032119914346895},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":10.01849315068493},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.004794520547945206}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075}}}}}}},"­":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}}}}},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},",":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"属":{"docs":{},"性":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"该":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"必":{"docs":{},"备":{"docs":{},"条":{"docs":{},"件":{"docs":{},"，":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.01707317073170732}}}}},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"e":{"docs":{},"l":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}},"的":{"docs":{},"键":{"docs":{},"上":{"docs":{},"，":{"docs":{},"当":{"docs":{},"然":{"docs":{},"其":{"docs":{},"键":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"对":{"docs":{},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"其":{"docs":{},"键":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"做":{"docs":{},"了":{"docs":{},"些":{"docs":{},"限":{"docs":{},"制":{"docs":{},"。":{"docs":{},"在":{"docs":{},"[":{"docs":{},"字":{"docs":{},"典":{"docs":{},"]":{"docs":{},"[":{"5":{"docs":{},"]":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"中":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"键":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"可":{"docs":{},"哈":{"docs":{},"希":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"有":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"其":{"docs":{},"是":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"之":{"docs":{},"所":{"docs":{},"以":{"docs":{},"需":{"docs":{},"要":{"docs":{},"其":{"docs":{},"键":{"docs":{},"是":{"docs":{},"可":{"docs":{},"哈":{"docs":{},"希":{"docs":{},"是":{"docs":{},"为":{"docs":{},"了":{"docs":{},"以":{"docs":{},"便":{"docs":{},"于":{"docs":{},"其":{"docs":{},"检":{"docs":{},"查":{"docs":{},"其":{"docs":{},"是":{"docs":{},"否":{"docs":{},"包":{"docs":{},"含":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"键":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"无":{"docs":{},"此":{"docs":{},"需":{"docs":{},"求":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"特":{"docs":{},"化":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"键":{"docs":{},"，":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"自":{"docs":{},"己":{"docs":{},"写":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"你":{"docs":{},"或":{"docs":{},"许":{"docs":{},"会":{"docs":{},"定":{"docs":{},"义":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"为":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"和":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},",":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.016216216216216217},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}}}}}}}}},"e":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.018050541516245487}},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.014285714285714285},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.007220216606498195}},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"以":{"0":{"docs":{},"为":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"每":{"docs":{},"一":{"docs":{},"次":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"使":{"docs":{},"用":{"docs":{},"前":{"docs":{},"置":{"docs":{},"自":{"docs":{},"增":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"(":{"docs":{},"+":{"docs":{},"+":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"等":{"docs":{},"于":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"自":{"docs":{},"增":{"docs":{},"后":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"候":{"docs":{},"如":{"docs":{},"果":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"等":{"docs":{},"于":{"7":{"docs":{},"时":{"docs":{},"，":{"docs":{},"就":{"docs":{},"超":{"docs":{},"过":{"docs":{},"了":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"值":{"docs":{},"，":{"docs":{},"会":{"docs":{},"被":{"docs":{},"重":{"docs":{},"置":{"docs":{},"为":{"1":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"的":{"docs":{},"取":{"docs":{},"值":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"会":{"docs":{},"一":{"docs":{},"直":{"docs":{},"是":{"1":{"docs":{},"，":{"2":{"docs":{},"，":{"3":{"docs":{},"，":{"4":{"docs":{},"，":{"5":{"docs":{},"，":{"6":{"docs":{},"，":{"1":{"docs":{},"，":{"2":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}}}}}},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.009626955475330927}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"三":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"追":{"docs":{},"踪":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"过":{"docs":{},"程":{"docs":{},"。":{"docs":{},"被":{"docs":{},"放":{"docs":{},"置":{"docs":{},"于":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"中":{"docs":{},"，":{"docs":{},"即":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"任":{"docs":{},"意":{"docs":{},"含":{"docs":{},"有":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"的":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"追":{"docs":{},"踪":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"含":{"docs":{},"有":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"前":{"docs":{},"者":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"有":{"docs":{},"几":{"docs":{},"个":{"docs":{},"面":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"为":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"后":{"docs":{},"者":{"docs":{},"为":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"桌":{"docs":{},"游":{"docs":{},"中":{"docs":{},"的":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"被":{"docs":{},"当":{"docs":{},"作":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}},"遵":{"docs":{},"循":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"属":{"docs":{},"性":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"将":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"会":{"docs":{},"将":{"docs":{},"旧":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"命":{"docs":{},"名":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"的":{"docs":{},"值":{"docs":{},"改":{"docs":{},"变":{"docs":{},"后":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"它":{"docs":{},"把":{"docs":{},"新":{"docs":{},"的":{"docs":{},"值":{"docs":{},"和":{"docs":{},"旧":{"docs":{},"的":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"对":{"docs":{},"比":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"总":{"docs":{},"的":{"docs":{},"步":{"docs":{},"数":{"docs":{},"增":{"docs":{},"加":{"docs":{},"了":{"docs":{},"，":{"docs":{},"就":{"docs":{},"输":{"docs":{},"出":{"docs":{},"一":{"docs":{},"个":{"docs":{},"消":{"docs":{},"息":{"docs":{},"表":{"docs":{},"示":{"docs":{},"增":{"docs":{},"加":{"docs":{},"了":{"docs":{},"多":{"docs":{},"少":{"docs":{},"步":{"docs":{},"。":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"或":{"docs":{},"属":{"docs":{},"性":{"docs":{},"自":{"docs":{},"身":{"docs":{},"的":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.011940298507462687}},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.028953229398663696}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.016666666666666666}},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"当":{"docs":{},"它":{"docs":{},"等":{"docs":{},"于":{"docs":{},".":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"打":{"docs":{},"印":{"docs":{},"“":{"docs":{},"l":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"推":{"docs":{},"断":{"docs":{},"当":{"docs":{},"它":{"docs":{},"被":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"更":{"docs":{},"短":{"docs":{},"的":{"docs":{},"点":{"docs":{},"（":{"docs":{},".":{"docs":{},"）":{"docs":{},"语":{"docs":{},"法":{"docs":{},"将":{"docs":{},"其":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.017817371937639197}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}},"n":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.012571428571428572},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.008849557522123894},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.012755102040816327},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.012867647058823529},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.028953229398663696},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.017241379310344827},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.00842358604091456},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"添":{"docs":{},"加":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"了":{"5":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"docs":{}}}}}},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}},"精":{"docs":{},"确":{"docs":{},"度":{"docs":{},"很":{"docs":{},"高":{"docs":{},"，":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"1":{"5":{"docs":{},"位":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"而":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"最":{"docs":{},"少":{"docs":{},"只":{"docs":{},"有":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}},"表":{"docs":{},"示":{"6":{"4":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}}},"[":{"docs":{},"]":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}},"和":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"型":{"docs":{},"的":{"docs":{},"值":{"1":{"docs":{},".":{"0":{"docs":{},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"1":{"docs":{},"米":{"docs":{},"”":{"docs":{},"。":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"为":{"docs":{},"什":{"docs":{},"么":{"docs":{},"m":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"—":{"docs":{},"—":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"1":{"docs":{},".":{"docs":{},"m":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"1":{"docs":{},".":{"0":{"docs":{},"的":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"docs":{}}},"docs":{},"看":{"docs":{},"作":{"docs":{},"是":{"docs":{},"某":{"docs":{},"单":{"docs":{},"位":{"docs":{},"下":{"docs":{},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"值":{"docs":{},"。":{"docs":{},"即":{"docs":{},"使":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},"为":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"一":{"docs":{},"个":{"docs":{},"带":{"docs":{},"有":{"docs":{},"d":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"(":{"docs":{},"我":{"docs":{},"们":{"docs":{},"假":{"docs":{},"设":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"在":{"docs":{},"[":{"0":{"docs":{},"，":{"1":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}},")":{"docs":{},"。":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"表":{"docs":{},"示":{"6":{"4":{"docs":{},"位":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"c":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}}}}}}}}}},"t":{"docs":{},"f":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"、":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.1251167133520075}},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"来":{"docs":{},"替":{"docs":{},"代":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"。":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"、":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"、":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"同":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"(":{"docs":{},".":{"docs":{},")":{"docs":{},"语":{"docs":{},"法":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"在":{"docs":{},"其":{"docs":{},"它":{"docs":{},"模":{"docs":{},"块":{"docs":{},"（":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"或":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"型":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"内":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"引":{"docs":{},"用":{"docs":{},"在":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"模":{"docs":{},"块":{"docs":{},"中":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"o":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}},"`":{"docs":{},"`":{"docs":{},"o":{"docs":{},"`":{"docs":{},"`":{"docs":{},"g":{"docs":{},"`":{"docs":{},"`":{"docs":{},"!":{"docs":{},"和":{"docs":{},"":{"docs":{},"":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.01312910284463895}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0087527352297593}},".":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"原":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}},"c":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"z":{"docs":{},"y":{"docs":{},"h":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}}}}}},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}},"(":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"n":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}},".":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.023333333333333334},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.01284796573875803},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}}}}}}}},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"数":{"docs":{},"组":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"。":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"语":{"docs":{},"法":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"实":{"docs":{},"例":{"docs":{},"值":{"docs":{},"（":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":3.333333333333333}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"e":{"docs":{},"­":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"{":{"docs":{},"­":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"­":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}},"。":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}},"表":{"docs":{},"示":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"t":{"docs":{},"的":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"e":{"docs":{},"a":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"t":{"docs":{},"有":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"t":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"安":{"docs":{},"全":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"在":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"保":{"docs":{},"证":{"docs":{},"支":{"docs":{},"持":{"docs":{},"等":{"docs":{},"式":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"说":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"事":{"docs":{},"实":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"“":{"docs":{},"任":{"docs":{},"何":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2894317578332448},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},"大":{"docs":{},"写":{"docs":{},"和":{"docs":{},"小":{"docs":{},"写":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},".":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"0":{"docs":{},"，":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},".":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"的":{"docs":{},"值":{"docs":{},"被":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"设":{"docs":{},"定":{"docs":{},"为":{"5":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"d":{"docs":{},"的":{"docs":{},"值":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"增":{"docs":{},"长":{"docs":{},"为":{"6":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}},"，":{"docs":{},"那":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"基":{"docs":{},"数":{"docs":{},"和":{"docs":{},"$":{"1":{"0":{"docs":{},"^":{"docs":{},"{":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}},"docs":{}},"2":{"docs":{},"^":{"docs":{},"{":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}},"docs":{}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5645107794361526},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3971991277088729},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.019178082191780823},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.036414565826330535}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"会":{"docs":{},"增":{"docs":{},"加":{"docs":{},"或":{"docs":{},"减":{"docs":{},"少":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"根":{"docs":{},"据":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"调":{"docs":{},"用":{"docs":{},"结":{"docs":{},"果":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"循":{"docs":{},"环":{"docs":{},"结":{"docs":{},"束":{"docs":{},"，":{"docs":{},"继":{"docs":{},"续":{"docs":{},"执":{"docs":{},"行":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"缀":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}},"强":{"docs":{},"制":{"docs":{},"取":{"docs":{},"值":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}}}}},"显":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}},"超":{"docs":{},"类":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}},"闭":{"docs":{},"包":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}}},"隐":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}},"二":{"docs":{},"元":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}},"前":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"型":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}},":":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},")":{"docs":{},"。":{"docs":{},"起":{"docs":{},"保":{"docs":{},"护":{"docs":{},"作":{"docs":{},"用":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"构":{"docs":{},"成":{"docs":{},"的":{"docs":{},"：":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"着":{"docs":{},"一":{"docs":{},"个":{"docs":{},"作":{"docs":{},"为":{"docs":{},"额":{"docs":{},"外":{"docs":{},"测":{"docs":{},"试":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"且":{"docs":{},"起":{"docs":{},"保":{"docs":{},"护":{"docs":{},"作":{"docs":{},"用":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"真":{"docs":{},"时":{"docs":{},"，":{"docs":{},"对":{"docs":{},"应":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"只":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"相":{"docs":{},"等":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"，":{"docs":{},"如":{"docs":{},"(":{"1":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"首":{"docs":{},"先":{"docs":{},"被":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"与":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"将":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"里":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"都":{"docs":{},"不":{"docs":{},"能":{"docs":{},"为":{"docs":{},"空":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"在":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"docs":{},"一":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"不":{"docs":{},"想":{"docs":{},"在":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"在":{"docs":{},"块":{"docs":{},"里":{"docs":{},"写":{"docs":{},"一":{"docs":{},"条":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.031609195402298854},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.00842358604091456},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"语":{"docs":{},"法":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6666666666666665}}}}}}}}}}}}}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23619450317124735},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.8746672582076308},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.014005602240896359}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"w":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}}}},"g":{"docs":{},"g":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.019693654266958426},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415}},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}},"c":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.015503875968992248},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}},"语":{"docs":{},"句":{"docs":{},"也":{"docs":{},"可":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}},"，":{"docs":{},"当":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}}}},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}}}}}}},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"d":{"5":{"7":{"8":{"8":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"，":{"docs":{},"超":{"docs":{},"过":{"3":{"0":{"docs":{},"人":{"docs":{},"参":{"docs":{},"与":{"docs":{},"翻":{"docs":{},"译":{"docs":{},"和":{"docs":{},"校":{"docs":{},"对":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"项":{"docs":{},"目":{"docs":{},"最":{"docs":{},"高":{"docs":{},"排":{"docs":{},"名":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},"总":{"docs":{},"榜":{"docs":{},"第":{"4":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.119514472455649}},"循":{"docs":{},"环":{"docs":{},"来":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"某":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"的":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"都":{"docs":{},"由":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"中":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"（":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"用":{"docs":{},"来":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"地":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"数":{"docs":{},"组":{"docs":{},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"）":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"（":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"）":{"docs":{},"，":{"docs":{},"区":{"docs":{},"间":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"半":{"docs":{},"闭":{"docs":{},"区":{"docs":{},"间":{"docs":{},"操":{"docs":{},"作":{"docs":{},"（":{"docs":{},".":{"docs":{},".":{"docs":{},"）":{"docs":{},"来":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"每":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"不":{"docs":{},"等":{"docs":{},"于":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"不":{"docs":{},"等":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"条":{"docs":{},"件":{"docs":{},"递":{"docs":{},"增":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9090909090909092}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"一":{"docs":{},"个":{"docs":{},"区":{"docs":{},"间":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"序":{"docs":{},"列":{"docs":{},"（":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{},"，":{"docs":{},"集":{"docs":{},"合":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"系":{"docs":{},"列":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"或":{"docs":{},"常":{"docs":{},"量":{"docs":{},"申":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"或":{"docs":{},"者":{"docs":{},"其":{"docs":{},"他":{"docs":{},"包":{"docs":{},"含":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"是":{"docs":{},"不":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"重":{"docs":{},"复":{"docs":{},"执":{"docs":{},"行":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"集":{"docs":{},"合":{"docs":{},"(":{"docs":{},"或":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"前":{"docs":{},"会":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"个":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"这":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"）":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"执":{"docs":{},"行":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"回":{"docs":{},"到":{"docs":{},"循":{"docs":{},"环":{"docs":{},"开":{"docs":{},"始":{"docs":{},"处":{"docs":{},"；":{"docs":{},"否":{"docs":{},"则":{"docs":{},"，":{"docs":{},"将":{"docs":{},"不":{"docs":{},"会":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.011204481792717087}}}}}}},"c":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"e":{"docs":{},"-":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}},"d":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}},"和":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"，":{"docs":{},"基":{"docs":{},"于":{"docs":{},"特":{"docs":{},"定":{"docs":{},"条":{"docs":{},"件":{"docs":{},"选":{"docs":{},"择":{"docs":{},"执":{"docs":{},"行":{"docs":{},"不":{"docs":{},"同":{"docs":{},"代":{"docs":{},"码":{"docs":{},"分":{"docs":{},"支":{"docs":{},"的":{"docs":{},"i":{"docs":{},"f":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"还":{"docs":{},"有":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"程":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"其":{"docs":{},"他":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"用":{"docs":{},"来":{"docs":{},"按":{"docs":{},"照":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"次":{"docs":{},"数":{"docs":{},"多":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"件":{"docs":{},"递":{"docs":{},"增":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"在":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"—":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"语":{"docs":{},"句":{"docs":{},"、":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"语":{"docs":{},"句":{"docs":{},"、":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"执":{"docs":{},"行":{"docs":{},"后":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"还":{"docs":{},"是":{"docs":{},"会":{"docs":{},"被":{"docs":{},"计":{"docs":{},"算":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"每":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"毕":{"docs":{},"后":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.008849557522123894},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}},"a":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},";":{"docs":{},")":{"docs":{},"元":{"docs":{},"组":{"docs":{},"把":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"b":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.011029411764705883}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}},"、":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"以":{"docs":{},"及":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"构":{"docs":{},"建":{"docs":{},"了":{"docs":{},"食":{"docs":{},"谱":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"味":{"docs":{},"调":{"docs":{},"味":{"docs":{},"剂":{"docs":{},"。":{"docs":{},"它":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"（":{"docs":{},"以":{"docs":{},"及":{"docs":{},"从":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"继":{"docs":{},"承":{"docs":{},"过":{"docs":{},"来":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"接":{"docs":{},"受":{"docs":{},"单":{"docs":{},"一":{"docs":{},"参":{"docs":{},"数":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"新":{"docs":{},"的":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"用":{"docs":{},"来":{"docs":{},"封":{"docs":{},"装":{"docs":{},"食":{"docs":{},"物":{"docs":{},"名":{"docs":{},"字":{"docs":{},"的":{"docs":{},"类":{"docs":{},"。":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"类":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}},"l":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}},"e":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"我":{"docs":{},"们":{"docs":{},"是":{"docs":{},"知":{"docs":{},"道":{"docs":{},"紧":{"docs":{},"急":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"重":{"docs":{},"置":{"docs":{},"的":{"docs":{},"密":{"docs":{},"码":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"整":{"docs":{},"个":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"还":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"事":{"docs":{},"实":{"docs":{},"上":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}},"l":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.1139122315592904}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.007619047619047619},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.119514472455649}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"详":{"docs":{},"情":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"贯":{"docs":{},"穿":{"docs":{},"（":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"里":{"docs":{},"，":{"docs":{},"但":{"docs":{},"不":{"docs":{},"能":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"传":{"docs":{},"递":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"。":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"从":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"传":{"docs":{},"递":{"docs":{},"是":{"docs":{},"无":{"docs":{},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"与":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"区":{"docs":{},"间":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9090909090909092}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}}}}}},"的":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"，":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.012867647058823529}},"时":{"docs":{},"为":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"b":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"采":{"docs":{},"用":{"docs":{},"了":{"docs":{},"很":{"docs":{},"多":{"docs":{},"传":{"docs":{},"统":{"docs":{},"上":{"docs":{},"只":{"docs":{},"被":{"docs":{},"类":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{},"所":{"docs":{},"支":{"docs":{},"持":{"docs":{},"的":{"docs":{},"特":{"docs":{},"征":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}},"s":{"docs":{},"和":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"都":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"1":{"docs":{},"跟":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"按":{"docs":{},"位":{"docs":{},"异":{"docs":{},"或":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"把":{"docs":{},"它":{"docs":{},"这":{"docs":{},"些":{"docs":{},"位":{"docs":{},"置":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"其":{"docs":{},"他":{"docs":{},"都":{"docs":{},"置":{"docs":{},"为":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}},"s":{"docs":{},"和":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"中":{"docs":{},"间":{"4":{"docs":{},"个":{"docs":{},"位":{"docs":{},"都":{"docs":{},"为":{"1":{"docs":{},"。":{"docs":{},"对":{"docs":{},"它":{"docs":{},"俩":{"docs":{},"进":{"docs":{},"行":{"docs":{},"按":{"docs":{},"位":{"docs":{},"与":{"docs":{},"运":{"docs":{},"算":{"docs":{},"后":{"docs":{},"，":{"docs":{},"就":{"docs":{},"得":{"docs":{},"到":{"docs":{},"了":{"0":{"0":{"1":{"1":{"1":{"1":{"0":{"0":{"docs":{},"，":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"6":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"e":{"docs":{},"r":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"为":{"1":{"0":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"为":{"4":{"2":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}},"来":{"docs":{},"防":{"docs":{},"止":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"重":{"docs":{},"写":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"：":{"docs":{},"@":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.010476190476190476},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.007220216606498195}},"e":{"docs":{},"、":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"、":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"和":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"方":{"docs":{},"式":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"只":{"docs":{},"会":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"进":{"docs":{},"行":{"docs":{},"计":{"docs":{},"算":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"表":{"docs":{},"现":{"docs":{},"得":{"docs":{},"比":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"更":{"docs":{},"好":{"docs":{},"。":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"方":{"docs":{},"式":{"docs":{},"会":{"docs":{},"在":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"没":{"docs":{},"有":{"docs":{},"超":{"docs":{},"出":{"docs":{},"后":{"docs":{},"直":{"docs":{},"接":{"docs":{},"运":{"docs":{},"行":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"表":{"docs":{},"明":{"docs":{},"你":{"docs":{},"必":{"docs":{},"须":{"docs":{},"刚":{"docs":{},"好":{"docs":{},"落":{"docs":{},"在":{"docs":{},"方":{"docs":{},"格":{"2":{"5":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"docs":{},"[":{"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"\"":{"docs":{},"m":{"docs":{},"i":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},">":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}},"中":{"docs":{},"这":{"docs":{},"个":{"docs":{},"单":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"写":{"docs":{},"做":{"docs":{},"：":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"现":{"docs":{},"在":{"docs":{},"则":{"docs":{},"可":{"docs":{},"以":{"docs":{},"成":{"docs":{},"功":{"docs":{},"的":{"docs":{},"编":{"docs":{},"译":{"docs":{},"过":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"作":{"docs":{},"用":{"docs":{},"于":{"docs":{},"任":{"docs":{},"何":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"如":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"或":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"用":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"。":{"docs":{},"请":{"docs":{},"注":{"docs":{},"意":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"非":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"功":{"docs":{},"能":{"docs":{},"是":{"docs":{},"去":{"docs":{},"查":{"docs":{},"找":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"给":{"docs":{},"定":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"若":{"docs":{},"查":{"docs":{},"找":{"docs":{},"到":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"，":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"该":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"在":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"反":{"docs":{},"之":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}},"）":{"docs":{},"，":{"docs":{},"它":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"是":{"docs":{},"当":{"docs":{},"前":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"(":{"2":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"并":{"docs":{},"指":{"docs":{},"定":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"4":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}}}}}}}},"表":{"docs":{},"示":{"3":{"2":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593}},"-":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"p":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"）":{"docs":{},"中":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"，":{"docs":{},"当":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"们":{"docs":{},"时":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"必":{"docs":{},"须":{"docs":{},"全":{"docs":{},"面":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"了":{"docs":{},".":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"那":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"将":{"docs":{},"无":{"docs":{},"法":{"docs":{},"通":{"docs":{},"过":{"docs":{},"编":{"docs":{},"译":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"没":{"docs":{},"有":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"到":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}},"a":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}},"r":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.010619469026548672}},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"从":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"!":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"改":{"docs":{},"为":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"o":{"docs":{},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"!":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"试":{"docs":{},"图":{"docs":{},"找":{"docs":{},"到":{"docs":{},"具":{"docs":{},"有":{"docs":{},"特":{"docs":{},"定":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"通":{"docs":{},"过":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"7":{"docs":{},"识":{"docs":{},"别":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"，":{"docs":{},"内":{"docs":{},"部":{"docs":{},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"；":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"也":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"其":{"docs":{},"外":{"docs":{},"部":{"docs":{},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"k":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"，":{"docs":{},"内":{"docs":{},"部":{"docs":{},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"k":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"都":{"docs":{},"将":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"摄":{"docs":{},"氏":{"docs":{},"温":{"docs":{},"度":{"docs":{},"值":{"docs":{},"，":{"docs":{},"并":{"docs":{},"保":{"docs":{},"存":{"docs":{},"在":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}}}}}},"e":{"docs":{},"e":{"docs":{},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.027428571428571427},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.03515151515151515},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.014925373134328358},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.04081632653061224},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.01935483870967742},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.027677496991576414},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.03866432337434095},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.016697588126159554},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.019498607242339833},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.011777301927194861},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.4929950669485553},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.01383399209486166},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455}},"s":{"docs":{},"）":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"与":{"docs":{},"调":{"docs":{},"用":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"定":{"docs":{},"义":{"docs":{},"在":{"docs":{},"全":{"docs":{},"局":{"docs":{},"域":{"docs":{},"中":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"把":{"docs":{},"函":{"docs":{},"数":{"docs":{},"定":{"docs":{},"义":{"docs":{},"在":{"docs":{},"别":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"中":{"docs":{},"，":{"docs":{},"称":{"docs":{},"作":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"尾":{"docs":{},"随":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"（":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}},"）":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"语":{"docs":{},"法":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"柯":{"docs":{},"里":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"(":{"docs":{},")":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"-":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"之":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"；":{"docs":{},"声":{"docs":{},"明":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"之":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"e":{"docs":{},"d":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"其":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"者":{"docs":{},"必":{"docs":{},"须":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"e":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"）":{"docs":{},"\\":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"a":{"docs":{},"）":{"docs":{},"、":{"docs":{},"回":{"docs":{},"车":{"docs":{},"符":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}},"c":{"docs":{},"）":{"docs":{},"以":{"docs":{},"及":{"docs":{},"空":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"）":{"docs":{},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"(":{"7":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{},")":{"docs":{},"和":{"docs":{},"f":{"docs":{},"(":{"docs":{},"x":{"docs":{},":":{"7":{"docs":{},")":{"docs":{},"都":{"docs":{},"是":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"x":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"有":{"docs":{},"效":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"f":{"docs":{},"(":{"7":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"x":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"e":{"docs":{},"e":{"docs":{},"k":{"5":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"docs":{}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.007220216606498195},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.061068702290076333},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"e":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"]":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.030534351145038167},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0061643835616438354}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"g":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112}},"s":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"。":{"docs":{},"（":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"申":{"docs":{},"明":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"你":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"协":{"docs":{},"议":{"docs":{},"里":{"docs":{},"它":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"地":{"docs":{},"方":{"docs":{},"实":{"docs":{},"现":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"以":{"docs":{},"各":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"满":{"docs":{},"足":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"属":{"docs":{},"性":{"docs":{},"声":{"docs":{},"明":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"词":{"docs":{},"，":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"可":{"docs":{},"读":{"docs":{},"写":{"docs":{},"（":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"属":{"docs":{},"性":{"docs":{},"不":{"docs":{},"能":{"docs":{},"以":{"docs":{},"常":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"只":{"docs":{},"读":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"属":{"docs":{},"性":{"docs":{},"声":{"docs":{},"明":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"声":{"docs":{},"明":{"docs":{},"值":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.14814814814814814},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.1111111111111111}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.1111111111111111},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"​":{"docs":{},"​":{"docs":{},"块":{"docs":{},"可":{"docs":{},"以":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"后":{"docs":{},"跟":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"构":{"docs":{},"成":{"docs":{},"，":{"docs":{},"用":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"后":{"docs":{},"跟":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}},"获":{"docs":{},"取":{"docs":{},"某":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"读":{"docs":{},"取":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"用":{"docs":{},"于":{"docs":{},"写":{"docs":{},"入":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"二":{"docs":{},"者":{"docs":{},"都":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"且":{"docs":{},"直":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"请":{"docs":{},"求":{"docs":{},"的":{"docs":{},"值":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"，":{"docs":{},"就":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"读":{"docs":{},"取":{"docs":{},"变":{"docs":{},"量":{"docs":{},"值":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"用":{"docs":{},"来":{"docs":{},"写":{"docs":{},"入":{"docs":{},"变":{"docs":{},"量":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"子":{"docs":{},"句":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"择":{"docs":{},"的":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"选":{"docs":{},"择":{"docs":{},"是":{"docs":{},"否":{"docs":{},"包":{"docs":{},"含":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"不":{"docs":{},"要":{"docs":{},"求":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"写":{"docs":{},"在":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}},"部":{"docs":{},"分":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"，":{"docs":{},"上":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"通":{"docs":{},"过":{"docs":{},"下":{"docs":{},"边":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"或":{"docs":{},"者":{"docs":{},"说":{"docs":{},"“":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"”":{"docs":{},"，":{"docs":{},"不":{"docs":{},"是":{"docs":{},"每":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"都":{"docs":{},"能":{"docs":{},"得":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"值":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"没":{"docs":{},"有":{"docs":{},"设":{"docs":{},"过":{"docs":{},"值":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"的":{"docs":{},"访":{"docs":{},"问":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"；":{"docs":{},"同":{"docs":{},"样":{"docs":{},"想":{"docs":{},"要":{"docs":{},"从":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"删":{"docs":{},"除":{"docs":{},"某":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"下":{"docs":{},"的":{"docs":{},"值":{"docs":{},"也":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"给":{"docs":{},"这":{"docs":{},"个":{"docs":{},"索":{"docs":{},"引":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"接":{"docs":{},"受":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316}}}}},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}},"b":{"docs":{},"y":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414}}}}}},"e":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}},"(":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"t":{"docs":{},"m":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"n":{"docs":{},"k":{"docs":{},"l":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"a":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.07407407407407407},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.021413276231263382},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.04201680672268908}}}}}},"p":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.016216216216216217}},"[":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811}}}}}}}}}},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.023880597014925373},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.10526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.025069637883008356},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.004794520547945206}},";":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}},"g":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},"！":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}},"­":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.025806451612903226},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.01444043321299639}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"去":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"时":{"docs":{},"，":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"严":{"docs":{},"格":{"docs":{},"必":{"docs":{},"须":{"docs":{},"的":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"中":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"影":{"docs":{},"响":{"docs":{},"到":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"歧":{"docs":{},"义":{"docs":{},"的":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"标":{"docs":{},"签":{"docs":{},"也":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"危":{"docs":{},"害":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"做":{"docs":{},"符":{"docs":{},"合":{"docs":{},"标":{"docs":{},"签":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"规":{"docs":{},"则":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"参":{"docs":{},"照":{"docs":{},"旁":{"docs":{},"边":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"结":{"docs":{},"束":{"docs":{},"本":{"docs":{},"次":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}},"跳":{"docs":{},"转":{"docs":{},"控":{"docs":{},"制":{"docs":{},"去":{"docs":{},"执":{"docs":{},"行":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}},",":{"docs":{},"d":{"1":{"2":{"docs":{},",":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}},"方":{"docs":{},"法":{"docs":{},"从":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"参":{"docs":{},"数":{"docs":{},"获":{"docs":{},"取":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"信":{"docs":{},"息":{"docs":{},"并":{"docs":{},"输":{"docs":{},"出":{"docs":{},"。":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"被":{"docs":{},"当":{"docs":{},"做":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"只":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}},"h":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"b":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}}}}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}}}}}}}}},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"a":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"y":{"docs":{},"m":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"w":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"a":{"docs":{},"s":{"docs":{},"?":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"将":{"docs":{},"其":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"/":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}},"d":{"docs":{},"o":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561}}},"y":{"docs":{},"）":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"但":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"值":{"docs":{},"（":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"）":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}},"e":{"docs":{},"和":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"产":{"docs":{},"生":{"docs":{},"的":{"docs":{},"。":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"它":{"docs":{},"所":{"docs":{},"替":{"docs":{},"代":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"约":{"docs":{},"束":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"任":{"docs":{},"何":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"所":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"要":{"docs":{},"求":{"docs":{},"满":{"docs":{},"足":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"也":{"docs":{},"必":{"docs":{},"须":{"docs":{},"满":{"docs":{},"足":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"f":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}},"r":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01}}}}}}}},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"a":{"docs":{},"o":{"docs":{},"z":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.007434944237918215},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.02181818181818182},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.007317073170731708},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.011494252873563218},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"-":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}},"p":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"成":{"docs":{},"员":{"docs":{},"：":{"docs":{},"给":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"常":{"docs":{},"量":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"全":{"docs":{},"名":{"docs":{},"来":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"没":{"docs":{},"有":{"docs":{},"显":{"docs":{},"式":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"里":{"docs":{},"，":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"使":{"docs":{},"用":{"docs":{},"缩":{"docs":{},"写":{"docs":{},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"来":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"的":{"docs":{},"值":{"docs":{},"已":{"docs":{},"经":{"docs":{},"知":{"docs":{},"道":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}}}}}}}},"x":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.03736263736263736},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.011643835616438357}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"'":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.011029411764705883},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414}},"=":{"docs":{},"\"":{"1":{"2":{"0":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}},"6":{"9":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}},"docs":{}},"3":{"5":{"7":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}},"8":{"7":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}},"docs":{}},"docs":{}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"2":{"0":{"0":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"4":{"0":{"4":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115}},".":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"1":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}}}},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.009523809523809525}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.011428571428571429}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"的":{"docs":{},"消":{"docs":{},"息":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"别":{"docs":{},"打":{"docs":{},"印":{"docs":{},"，":{"docs":{},"证":{"docs":{},"明":{"docs":{},"了":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"解":{"docs":{},"决":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"这":{"docs":{},"样":{"docs":{},"编":{"docs":{},"写":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"和":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"只":{"docs":{},"是":{"docs":{},"在":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"多":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"占":{"docs":{},"有":{"docs":{},"列":{"docs":{},"表":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"，":{"docs":{},"占":{"docs":{},"有":{"docs":{},"列":{"docs":{},"表":{"docs":{},"是":{"docs":{},"[":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"产":{"docs":{},"生":{"docs":{},"了":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}},"只":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"（":{"docs":{},"如":{"docs":{},"果":{"docs":{},"有":{"docs":{},"的":{"docs":{},"话":{"docs":{},"）":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"该":{"docs":{},"类":{"docs":{},"也":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"当":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"代":{"docs":{},"表":{"docs":{},"段":{"docs":{},"落":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"代":{"docs":{},"表":{"docs":{},"换":{"docs":{},"行":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"r":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"。":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"，":{"docs":{},"将":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"还":{"docs":{},"是":{"1":{"9":{"2":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"全":{"docs":{},"高":{"docs":{},"清":{"docs":{},"视":{"docs":{},"频":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"(":{"1":{"9":{"2":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"予":{"docs":{},"给":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"将":{"docs":{},"h":{"docs":{},"d":{"docs":{},"中":{"docs":{},"所":{"docs":{},"储":{"docs":{},"存":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"进":{"docs":{},"行":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"将":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"储":{"docs":{},"存":{"docs":{},"到":{"docs":{},"新":{"docs":{},"的":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"。":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"两":{"docs":{},"个":{"docs":{},"完":{"docs":{},"全":{"docs":{},"独":{"docs":{},"立":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"碰":{"docs":{},"巧":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"两":{"docs":{},"者":{"docs":{},"相":{"docs":{},"互":{"docs":{},"独":{"docs":{},"立":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"将":{"docs":{},"c":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"2":{"0":{"4":{"8":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"影":{"docs":{},"响":{"docs":{},"h":{"docs":{},"d":{"docs":{},"中":{"docs":{},"的":{"docs":{},"宽":{"docs":{},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"a":{"docs":{},"y":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}},"c":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"b":{"docs":{},"r":{"docs":{},"o":{"docs":{},"k":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0380952380952381},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"!":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"设":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"后":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}},",":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"被":{"docs":{},"设":{"docs":{},"定":{"docs":{},"为":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"都":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"后":{"docs":{},"，":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}},"docs":{}},"docs":{}}}}}}}},"现":{"docs":{},"在":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"变":{"docs":{},"量":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{},"某":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"客":{"docs":{},"户":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"里":{"docs":{},"的":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"这":{"docs":{},"里":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"两":{"docs":{},"层":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"来":{"docs":{},"联":{"docs":{},"系":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"和":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"'":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}}},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"!":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},"?":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"[":{"0":{"docs":{},"]":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}}}},"docs":{}}},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"运":{"docs":{},"行":{"docs":{},"通":{"docs":{},"过":{"docs":{},"，":{"docs":{},"且":{"docs":{},"会":{"docs":{},"将":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"现":{"docs":{},"在":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"现":{"docs":{},"在":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"面":{"docs":{},"，":{"docs":{},"在":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"括":{"docs":{},"号":{"docs":{},"的":{"docs":{},"前":{"docs":{},"面":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}},"s":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}},"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01818181818181818}}}},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}},"i":{"docs":{},"c":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415}}}}}},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"i":{"docs":{},"f":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"说":{"docs":{},"他":{"docs":{},"平":{"docs":{},"时":{"1":{"2":{"docs":{},"点":{"docs":{},"就":{"docs":{},"会":{"docs":{},"睡":{"docs":{},"，":{"1":{"docs":{},"点":{"4":{"7":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"'":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.024498886414253896}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.022900763358778626}},"）":{"docs":{},"根":{"docs":{},"据":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"先":{"docs":{},"后":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2894317578332448},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.015384615384615385},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"a":{"docs":{},"l":{"docs":{},")":{"docs":{},"即":{"docs":{},"可":{"docs":{},"触":{"docs":{},"发":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"测":{"docs":{},"。":{"docs":{},"（":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"就":{"docs":{},"是":{"docs":{},"会":{"docs":{},"直":{"docs":{},"接":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"你":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"4":{"2":{"docs":{},"和":{"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}}}},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"f":{"docs":{},"e":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"作":{"docs":{},"为":{"docs":{},"随":{"docs":{},"机":{"docs":{},"数":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"传":{"docs":{},"入":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"类":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"并":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"线":{"docs":{},"性":{"docs":{},"同":{"docs":{},"余":{"docs":{},"生":{"docs":{},"成":{"docs":{},"器":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"h":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}},"v":{"docs":{},"e":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"x":{"docs":{},"d":{"docs":{},"x":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"y":{"docs":{},"u":{"docs":{},"k":{"docs":{},"a":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.011204481792717087}}}}}},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}}}}}},"c":{"docs":{},"h":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"'":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}}}},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.009626955475330927}},"s":{"docs":{},"）":{"docs":{},"的":{"docs":{},"小":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"，":{"docs":{},"也":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"滑":{"docs":{},"道":{"docs":{},"和":{"docs":{},"梯":{"docs":{},"子":{"docs":{},"（":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"章":{"docs":{},"节":{"docs":{},"有":{"docs":{},"该":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"详":{"docs":{},"细":{"docs":{},"介":{"docs":{},"绍":{"docs":{},")":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"新":{"docs":{},"版":{"docs":{},"本":{"docs":{},"。":{"docs":{},"新":{"docs":{},"版":{"docs":{},"本":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"作":{"docs":{},"为":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"z":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368}}},"y":{"docs":{},"，":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"只":{"docs":{},"有":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"被":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"才":{"docs":{},"被":{"docs":{},"创":{"docs":{},"建":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}}}}}}}},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}}}}}},"s":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}},"t":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}},"(":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"前":{"docs":{},"缀":{"docs":{},"）":{"docs":{},"或":{"docs":{},"者":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"给":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"用":{"docs":{},"关":{"docs":{},"键":{"docs":{},"之":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}},"将":{"docs":{},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}},"（":{"docs":{},"或":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"）":{"docs":{},"语":{"docs":{},"句":{"docs":{},"来":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"）":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"其":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"起":{"docs":{},"保":{"docs":{},"护":{"docs":{},"作":{"docs":{},"用":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"和":{"docs":{},"其":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"里":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}}},"f":{"docs":{},"t":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.03870967741935484},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.016697588126159554},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}}},"和":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"，":{"docs":{},"代":{"docs":{},"表":{"docs":{},"+":{"docs":{},"左":{"docs":{},"边":{"docs":{},"和":{"docs":{},"右":{"docs":{},"边":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{},"对":{"docs":{},"象":{"docs":{},"。":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{},"的":{"docs":{},"对":{"docs":{},"象":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"x":{"docs":{},"和":{"docs":{},"y":{"docs":{},"分":{"docs":{},"别":{"docs":{},"等":{"docs":{},"于":{"docs":{},"两":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"对":{"docs":{},"象":{"docs":{},"的":{"docs":{},"x":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"为":{"1":{"4":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}}}}}},"-":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.02040816326530612},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"测":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"的":{"docs":{},"已":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"的":{"docs":{},"最":{"docs":{},"高":{"docs":{},"等":{"docs":{},"级":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"被":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"与":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"配":{"docs":{},"合":{"docs":{},"工":{"docs":{},"作":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"：":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"新":{"docs":{},"等":{"docs":{},"级":{"docs":{},"被":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"更":{"docs":{},"新":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"：":{"docs":{},"如":{"docs":{},"果":{"docs":{},"某":{"docs":{},"个":{"docs":{},"给":{"docs":{},"定":{"docs":{},"的":{"docs":{},"等":{"docs":{},"级":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{},"（":{"docs":{},"注":{"docs":{},"意":{"docs":{},"：":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"我":{"docs":{},"们":{"docs":{},"没":{"docs":{},"有":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"似":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"的":{"docs":{},"写":{"docs":{},"法":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"还":{"docs":{},"是":{"docs":{},"能":{"docs":{},"够":{"docs":{},"访":{"docs":{},"问":{"docs":{},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"监":{"docs":{},"测":{"docs":{},"每":{"docs":{},"个":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"的":{"docs":{},"进":{"docs":{},"度":{"docs":{},"。":{"docs":{},"它":{"docs":{},"用":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"一":{"docs":{},"起":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"。":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"0":{"docs":{},"到":{"2":{"5":{"5":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"(":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"整":{"docs":{},"数":{"docs":{},")":{"docs":{},"；":{"docs":{},"与":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"整":{"docs":{},"数":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"它":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"任":{"docs":{},"何":{"docs":{},"下":{"docs":{},"划":{"docs":{},"线":{"docs":{},"字":{"docs":{},"符":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"，":{"docs":{},"但":{"docs":{},"它":{"docs":{},"仅":{"docs":{},"用":{"docs":{},"作":{"docs":{},"与":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"比":{"docs":{},"较":{"docs":{},"(":{"docs":{},"大":{"docs":{},"小":{"docs":{},")":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"可":{"docs":{},"以":{"docs":{},"同":{"docs":{},"时":{"docs":{},"被":{"docs":{},"两":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"使":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"2":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0087527352297593}}}},"o":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"i":{"docs":{},"c":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"环":{"docs":{},"境":{"docs":{},"下":{"docs":{},"。":{"docs":{},"此":{"docs":{},"时":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"?":{"docs":{},"实":{"docs":{},"例":{"docs":{},"包":{"docs":{},"含":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"t":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"值":{"docs":{},"为":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},")":{"docs":{},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"此":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"k":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}},"p":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.01680672268907563}}}}}}}}},"w":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.01312910284463895}}}}},"g":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}}}},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},";":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},";":{"docs":{},"和":{"docs":{},"右":{"docs":{},"移":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}},"g":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"]":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"、":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"­":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"­":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899}}}}}}},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"a":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}}}},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"k":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"(":{"docs":{},"初":{"docs":{},"始":{"docs":{},"为":{"0":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"其":{"docs":{},"外":{"docs":{},"部":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"其":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"子":{"docs":{},"类":{"docs":{},"中":{"docs":{},"定":{"docs":{},"制":{"docs":{},"这":{"docs":{},"些":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"或":{"docs":{},"添":{"docs":{},"加":{"docs":{},"新":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"来":{"docs":{},"更":{"docs":{},"好":{"docs":{},"地":{"docs":{},"描":{"docs":{},"述":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"s":{"docs":{},"或":{"docs":{},"者":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"（":{"docs":{},"比":{"docs":{},"如":{"docs":{},"数":{"docs":{},"字":{"1":{"0":{"docs":{},"或":{"docs":{},"者":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"给":{"docs":{},"它":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"1":{"0":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"并":{"docs":{},"将":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"所":{"docs":{},"有":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.016728624535315983}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015}},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}},"e":{"docs":{},"s":{"docs":{},"y":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"尾":{"docs":{},"随":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"将":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"数":{"docs":{},"组":{"docs":{},"[":{"1":{"6":{"docs":{},",":{"5":{"8":{"docs":{},",":{"5":{"1":{"0":{"docs":{},"]":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{},"包":{"docs":{},"含":{"docs":{},"对":{"docs":{},"应":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"[":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"）":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"值":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9090909090909092}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"特":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"”":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"“":{"docs":{},"最":{"docs":{},"大":{"docs":{},"适":{"docs":{},"合":{"docs":{},"”":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"2":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}},"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.021621621621621623}},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}},"[":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"2":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{}},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"阅":{"docs":{},"读":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"从":{"docs":{},"左":{"docs":{},"上":{"docs":{},"到":{"docs":{},"右":{"docs":{},"下":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"实":{"docs":{},"例":{"docs":{},"中":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"实":{"docs":{},"例":{"docs":{},"g":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"两":{"docs":{},"个":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"入":{"docs":{},"参":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"s":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"足":{"docs":{},"够":{"docs":{},"容":{"docs":{},"纳":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"将":{"docs":{},"呈":{"docs":{},"现":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"二":{"docs":{},"维":{"docs":{},"矩":{"docs":{},"阵":{"docs":{},"。":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"中":{"docs":{},"同":{"docs":{},"时":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"效":{"docs":{},"的":{"docs":{},"判":{"docs":{},"断":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"方":{"docs":{},"便":{"docs":{},"进":{"docs":{},"行":{"docs":{},"断":{"docs":{},"言":{"docs":{},"，":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"确":{"docs":{},"认":{"docs":{},"入":{"docs":{},"参":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"或":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}},"d":{"docs":{},"e":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}},"e":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.4653948535936113},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"）":{"docs":{},"，":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}},"类":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}},",":{"docs":{},"类":{"docs":{},"似":{"docs":{},"于":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"用":{"docs":{},"来":{"docs":{},"移":{"docs":{},"动":{"docs":{},"点":{"docs":{},"。":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"修":{"docs":{},"改":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"点":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"点":{"docs":{},"。":{"docs":{},"方":{"docs":{},"法":{"docs":{},"定":{"docs":{},"义":{"docs":{},"时":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"提":{"docs":{},"供":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"所":{"docs":{},"代":{"docs":{},"表":{"docs":{},"的":{"docs":{},"值":{"docs":{},"相":{"docs":{},"关":{"docs":{},"联":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"。":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"来":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"；":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"原":{"docs":{},"始":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"；":{"docs":{},"可":{"docs":{},"以":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}},"下":{"docs":{},"标":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"）":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6666666666666665}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}},"修":{"docs":{},"改":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"变":{"docs":{},"异":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"局":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"和":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"方":{"docs":{},"法":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"当":{"docs":{},"前":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.017241379310344827}}}},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.010619469026548672},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.6985484530462042},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}},"）":{"docs":{},"中":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"这":{"docs":{},"个":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"在":{"docs":{},"某":{"docs":{},"个":{"docs":{},"文":{"docs":{},"件":{"docs":{},"的":{"docs":{},"顶":{"docs":{},"端":{"docs":{},"（":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.026726057906458798}},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"能":{"docs":{},"够":{"docs":{},"使":{"docs":{},"用":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"不":{"docs":{},"确":{"docs":{},"定":{"docs":{},"，":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.45008873114463177},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.019332161687170474},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"方":{"docs":{},"法":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"方":{"docs":{},"法":{"docs":{},"内":{"docs":{},"部":{"docs":{},"改":{"docs":{},"变":{"docs":{},"它":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"；":{"docs":{},"并":{"docs":{},"且":{"docs":{},"它":{"docs":{},"做":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"改":{"docs":{},"变":{"docs":{},"在":{"docs":{},"方":{"docs":{},"法":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"还":{"docs":{},"会":{"docs":{},"保":{"docs":{},"留":{"docs":{},"在":{"docs":{},"原":{"docs":{},"始":{"docs":{},"结":{"docs":{},"构":{"docs":{},"中":{"docs":{},"。":{"docs":{},"方":{"docs":{},"法":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"给":{"docs":{},"它":{"docs":{},"隐":{"docs":{},"含":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"是":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23498238195912613}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.007434944237918215},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"e":{"docs":{},"r":{"docs":{},"作":{"docs":{},"为":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}},"s":{"docs":{},"b":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"m":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"用":{"docs":{},"户":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.007905138339920948}}}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.007317073170731708}}}}}}}}},"l":{"docs":{},"k":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0087527352297593}},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}}},"d":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}},"p":{"docs":{},"h":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.014652014652014652}}}},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"r":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}},"e":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.007272727272727273}},"(":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}}}}}}},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0935412026726058}},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499}}}}}},".":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599}}}}}}},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"三":{"docs":{},"个":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"在":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"时":{"docs":{},"根":{"docs":{},"据":{"docs":{},"它":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"所":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"推":{"docs":{},"断":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"用":{"docs":{},"于":{"docs":{},"打":{"docs":{},"印":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"它":{"docs":{},"的":{"docs":{},"导":{"docs":{},"演":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"。":{"docs":{},"当":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"真":{"docs":{},"的":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"（":{"docs":{},"这":{"docs":{},"个":{"docs":{},"是":{"docs":{},"为":{"docs":{},"了":{"docs":{},"判":{"docs":{},"断":{"docs":{},"下":{"docs":{},"转":{"docs":{},"是":{"docs":{},"否":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{},"）":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"写":{"docs":{},"的":{"docs":{},"“":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}},"d":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},")":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"h":{"docs":{},"d":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"(":{"1":{"9":{"2":{"0":{"docs":{},"*":{"1":{"0":{"8":{"0":{"docs":{},")":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"(":{"docs":{},"h":{"docs":{},"d":{"docs":{},")":{"docs":{},"。":{"docs":{},"同":{"docs":{},"时":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"交":{"docs":{},"错":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},",":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"“":{"1":{"0":{"8":{"0":{"docs":{},"i":{"docs":{},"”":{"docs":{},"。":{"docs":{},"最":{"docs":{},"后":{"docs":{},"，":{"docs":{},"其":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"是":{"2":{"5":{"docs":{},".":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}}},"u":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"只":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"b":{"docs":{},"b":{"docs":{},"b":{"docs":{},"b":{"docs":{},"b":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.015238095238095238}},"!":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}}},"docs":{}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.016},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.008484848484848486},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.029850746268656716},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.017142857142857144},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.03184713375796178},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.006857142857142857}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.012755102040816327}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"0":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"docs":{}}}}}}}}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316}}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"并":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"出":{"docs":{},"了":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"对":{"docs":{},"键":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"s":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"存":{"docs":{},"放":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"为":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.025806451612903226}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707}},"s":{"docs":{},"是":{"docs":{},"非":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"）":{"docs":{},"时":{"docs":{},"这":{"docs":{},"一":{"docs":{},"点":{"docs":{},"也":{"docs":{},"成":{"docs":{},"立":{"docs":{},"。":{"docs":{},"只":{"docs":{},"要":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"的":{"docs":{},"请":{"docs":{},"求":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"最":{"docs":{},"后":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"总":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"操":{"docs":{},"作":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"称":{"docs":{},"作":{"docs":{},"“":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"”":{"docs":{},"。":{"docs":{},"当":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"是":{"docs":{},"空":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"（":{"docs":{},"上":{"docs":{},"例":{"docs":{},"）":{"docs":{},"，":{"docs":{},"选":{"docs":{},"择":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"将":{"docs":{},"会":{"docs":{},"为":{"docs":{},"空":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"会":{"docs":{},"出":{"docs":{},"先":{"docs":{},"无":{"docs":{},"法":{"docs":{},"访":{"docs":{},"问":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095}},"是":{"docs":{},"否":{"docs":{},"是":{"docs":{},"拉":{"docs":{},"丁":{"docs":{},"，":{"docs":{},"阿":{"docs":{},"拉":{"docs":{},"伯":{"docs":{},"，":{"docs":{},"中":{"docs":{},"文":{"docs":{},"或":{"docs":{},"者":{"docs":{},"泰":{"docs":{},"语":{"docs":{},"中":{"docs":{},"的":{"1":{"docs":{},"到":{"4":{"docs":{},"之":{"docs":{},"一":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"，":{"docs":{},"该":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"语":{"docs":{},"句":{"docs":{},"给":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01}}}}}}},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}},"变":{"docs":{},"量":{"docs":{},"之":{"docs":{},"后":{"docs":{},"除":{"docs":{},"以":{"1":{"0":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}},"docs":{}},"docs":{}}}}}}},"值":{"docs":{},"和":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"可":{"docs":{},"以":{"docs":{},"确":{"docs":{},"保":{"docs":{},"当":{"docs":{},"创":{"docs":{},"建":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"总":{"docs":{},"是":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.021714285714285714},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.015317286652078774},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.2410429880197322},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.8772182786157942},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.009191176470588236},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.030476190476190476},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.03503184713375796},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.01444043321299639},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.00691699604743083},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.029978586723768737},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.011204481792717087}},"=":{"docs":{},"\"":{"1":{"docs":{},"\"":{"docs":{},">":{"docs":{},"解":{"docs":{},"决":{"docs":{},"实":{"docs":{},"例":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}},">":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"<":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":5}}}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"\"":{"docs":{},">":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":5.001904761904762}}}}}}}}}}}},"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"实":{"docs":{},"参":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":5.00763358778626}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}},">":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"<":{"docs":{},"a":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":5}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"o":{"docs":{},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"_":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}},"l":{"docs":{},"f":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"y":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"w":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"_":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"_":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"_":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"_":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"_":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}},"n":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"s":{"docs":{},"_":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"_":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"y":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}},"docs":{}},"8":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"_":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"_":{"docs":{},"a":{"docs":{},"_":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"y":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"_":{"docs":{},"o":{"docs":{},"f":{"docs":{},"_":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"_":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"y":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"_":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}},"-":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"_":{"docs":{},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"_":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"_":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"_":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"\"":{"docs":{},">":{"docs":{},"<":{"docs":{},"/":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}},"e":{"docs":{},"的":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"接":{"docs":{},"收":{"docs":{},"两":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"半":{"docs":{},"径":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"实":{"docs":{},"现":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"和":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}},"协":{"docs":{},"议":{"docs":{},"包":{"docs":{},"含":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"；":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"协":{"docs":{},"议":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"[":{"1":{"6":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}},"docs":{}}}}}}}}}}}},"）":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}},"简":{"docs":{},"写":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}},"数":{"docs":{},"组":{"docs":{},"确":{"docs":{},"已":{"docs":{},"被":{"docs":{},"复":{"docs":{},"制":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"将":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"从":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"修":{"docs":{},"改":{"docs":{},"为":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},",":{"docs":{},"则":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"仍":{"docs":{},"是":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"发":{"docs":{},"生":{"docs":{},"前":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"o":{"docs":{},"h":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"七":{"docs":{},"个":{"docs":{},"人":{"docs":{},"名":{"docs":{},"。":{"docs":{},"还":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"用":{"docs":{},"以":{"docs":{},"储":{"docs":{},"存":{"docs":{},"在":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"上":{"docs":{},"调":{"docs":{},"用":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.008571428571428572}}}}}}}}}}}}},"e":{"docs":{},"w":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"和":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"相":{"docs":{},"同":{"docs":{},"。":{"docs":{},"与":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"入":{"docs":{},"参":{"docs":{},"声":{"docs":{},"明":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"就":{"docs":{},"算":{"docs":{},"不":{"docs":{},"写":{"docs":{},"，":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"e":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"参":{"docs":{},"见":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}},"x":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"，":{"docs":{},"开":{"docs":{},"关":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"电":{"docs":{},"源":{"docs":{},"状":{"docs":{},"态":{"docs":{},"（":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"，":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"，":{"docs":{},"h":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}},"a":{"docs":{},"r":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.01532567049808429}}}}},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":5.021238938053098},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.024761904761904763},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.013927576601671309},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.00691699604743083}},"，":{"docs":{},"?":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"整":{"docs":{},"个":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"件":{"docs":{},"会":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"被":{"docs":{},"跳":{"docs":{},"过":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"会":{"docs":{},"将":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}},"但":{"docs":{},"是":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"运":{"docs":{},"行":{"docs":{},"需":{"docs":{},"要":{"docs":{},"一":{"docs":{},"个":{"docs":{},"非":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}},"因":{"docs":{},"为":{"docs":{},"非":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}},"不":{"docs":{},"是":{"docs":{},"指":{"docs":{},"针":{"docs":{},"—":{"docs":{},"—":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"确":{"docs":{},"定":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"值":{"docs":{},"缺":{"docs":{},"失":{"docs":{},"。":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"话":{"docs":{},"请":{"docs":{},"不":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"解":{"docs":{},"析":{"docs":{},"可":{"docs":{},"选":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"中":{"docs":{},"判":{"docs":{},"断":{"docs":{},"是":{"docs":{},"否":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"使":{"docs":{},"用":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"后":{"docs":{},"再":{"docs":{},"也":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"式":{"docs":{},"断":{"docs":{},"开":{"docs":{},"两":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"）":{"docs":{},"包":{"docs":{},"括":{"docs":{},"最":{"docs":{},"先":{"docs":{},"的":{"docs":{},"那":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"）":{"docs":{},"，":{"docs":{},"只":{"docs":{},"留":{"docs":{},"下":{"docs":{},"一":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"选":{"docs":{},"项":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"运":{"docs":{},"行":{"docs":{},"错":{"docs":{},"误":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"内":{"docs":{},"的":{"docs":{},"占":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"总":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"当":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"销":{"docs":{},"毁":{"docs":{},"后":{"docs":{},"，":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"值":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"循":{"docs":{},"环":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"了":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"和":{"docs":{},"前":{"docs":{},"面":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"来":{"docs":{},"获":{"docs":{},"得":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"不":{"docs":{},"论":{"docs":{},"你":{"docs":{},"调":{"docs":{},"用":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"、":{"docs":{},"方":{"docs":{},"法":{"docs":{},"、":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"等":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"不":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"结":{"docs":{},"果":{"docs":{},"都":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"利":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"来":{"docs":{},"检":{"docs":{},"测":{"docs":{},"你":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"是":{"docs":{},"否":{"docs":{},"调":{"docs":{},"用":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"有":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"即":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"i":{"docs":{},"a":{"docs":{},"o":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"的":{"docs":{},"非":{"docs":{},"结":{"docs":{},"合":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"不":{"docs":{},"以":{"docs":{},"任":{"docs":{},"何":{"docs":{},"形":{"docs":{},"式":{"docs":{},"分":{"docs":{},"组":{"docs":{},"。":{"docs":{},"具":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"的":{"docs":{},"非":{"docs":{},"结":{"docs":{},"合":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"互":{"docs":{},"相":{"docs":{},"邻":{"docs":{},"接":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"1":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.007272727272727273},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.020671834625323},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.015306122448979591},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.05161290322580645},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.015817223198594025},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"”":{"docs":{},"。":{"docs":{},"当":{"docs":{},"它":{"docs":{},"等":{"docs":{},"于":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"打":{"docs":{},"印":{"docs":{},"“":{"docs":{},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"h":{"docs":{},"，":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"和":{"docs":{},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"）":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"成":{"docs":{},"员":{"docs":{},"）":{"docs":{},"。":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.042105263157894736}},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"(":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},")":{"docs":{},"为":{"docs":{},"用":{"docs":{},"该":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"经":{"docs":{},"用":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"你":{"docs":{},"则":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"为":{"docs":{},"没":{"docs":{},"使":{"docs":{},"用":{"docs":{},"该":{"docs":{},"特":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"。":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"规":{"docs":{},"则":{"docs":{},"试":{"docs":{},"用":{"docs":{},"于":{"docs":{},"当":{"docs":{},"你":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"似":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"）":{"docs":{},"来":{"docs":{},"暗":{"docs":{},"示":{"docs":{},"值":{"docs":{},"缺":{"docs":{},"失":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"假":{"docs":{},"设":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"知":{"docs":{},"道":{"docs":{},"并":{"docs":{},"记":{"docs":{},"得":{"docs":{},"对":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"判":{"docs":{},"断":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"该":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"是":{"docs":{},"否":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"/":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"您":{"docs":{},"传":{"docs":{},"递":{"docs":{},"或":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"的":{"docs":{},"是":{"docs":{},"该":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"描":{"docs":{},"述":{"docs":{},"在":{"docs":{},"本":{"docs":{},"质":{"docs":{},"上":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"后":{"docs":{},"者":{"docs":{},"是":{"docs":{},"以":{"docs":{},"类":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"前":{"docs":{},"者":{"docs":{},"是":{"docs":{},"以":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"和":{"docs":{},"n":{"docs":{},"s":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"与":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"中":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"子":{"docs":{},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"变":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"表":{"docs":{},"明":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"和":{"docs":{},"实":{"docs":{},"现":{"docs":{},"由":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"1":{"7":{"0":{"1":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},".":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"p":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"p":{"docs":{},"-":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"告":{"docs":{},"诉":{"docs":{},"我":{"docs":{},"，":{"docs":{},"这":{"docs":{},"几":{"docs":{},"天":{"docs":{},"太":{"docs":{},"累":{"docs":{},"了":{"docs":{},"，":{"docs":{},"校":{"docs":{},"对":{"docs":{},"到":{"docs":{},"一":{"docs":{},"半":{"docs":{},"睡":{"docs":{},"着":{"docs":{},"了":{"docs":{},"，":{"docs":{},"醒":{"docs":{},"来":{"docs":{},"又":{"docs":{},"继":{"docs":{},"续":{"docs":{},"做":{"docs":{},"。":{"2":{"docs":{},"点":{"1":{"7":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"字":{"docs":{},"典":{"docs":{},"时":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"每":{"docs":{},"项":{"docs":{},"元":{"docs":{},"素":{"docs":{},"会":{"docs":{},"以":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198}}}},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513}}}}}}}}}}}}}}}},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364}},"d":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":1.6533615221987317},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.8746672582076308},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.023554603854389723},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.030534351145038167},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}},"s":{"docs":{},"）":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"变":{"docs":{},"量":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}}},"无":{"docs":{},"参":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}},"输":{"docs":{},"入":{"docs":{},"输":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},")":{"docs":{},"或":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"在":{"docs":{},"相":{"docs":{},"关":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"中":{"docs":{},"访":{"docs":{},"问":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"i":{"docs":{},"]":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"）":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"用":{"docs":{},"于":{"docs":{},"元":{"docs":{},"素":{"docs":{},"访":{"docs":{},"问":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"每":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"必":{"docs":{},"须":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"定":{"docs":{},"每":{"docs":{},"种":{"docs":{},"索":{"docs":{},"引":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"注":{"docs":{},"。":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"不":{"docs":{},"支":{"docs":{},"持":{"docs":{},"默":{"docs":{},"认":{"docs":{},"参":{"docs":{},"数":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00684931506849315}},"e":{"docs":{},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"­":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619}},"变":{"docs":{},"量":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"打":{"docs":{},"破":{"docs":{},"它":{"docs":{},"持":{"docs":{},"有":{"docs":{},"的":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.2298850574712645},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.010958904109589041},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0196078431372549}},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{},"的":{"docs":{},"，":{"docs":{},"和":{"docs":{},"其":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"中":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"事":{"docs":{},"件":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"在":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"事":{"docs":{},"件":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}},"s":{"docs":{},"）":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}}}}},"）":{"docs":{},"代":{"docs":{},"表":{"docs":{},"了":{"docs":{},"单":{"docs":{},"个":{"docs":{},"值":{"docs":{},"或":{"docs":{},"者":{"docs":{},"复":{"docs":{},"合":{"docs":{},"值":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"元":{"docs":{},"组":{"docs":{},"(":{"1":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}}}}},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}},"和":{"docs":{},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}},"枚":{"docs":{},"举":{"docs":{},"案":{"docs":{},"例":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":1.1111111111111112}}}}}}}}}}}}}}}}}},"，":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.02857142857142857},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01592356687898089},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"'":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}}}}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"?":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"按":{"docs":{},"照":{"docs":{},"代":{"docs":{},"码":{"docs":{},"片":{"docs":{},"段":{"docs":{},"中":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"，":{"docs":{},"为":{"docs":{},"新":{"docs":{},"的":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"建":{"docs":{},"立":{"docs":{},"多":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"这":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"是":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"?":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"值":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"目":{"docs":{},"前":{"docs":{},"还":{"docs":{},"不":{"docs":{},"会":{"docs":{},"引":{"docs":{},"用":{"docs":{},"到":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"并":{"docs":{},"将":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"一":{"docs":{},"致":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{},"。":{"docs":{},"这":{"docs":{},"一":{"docs":{},"次":{"docs":{},"，":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"展":{"docs":{},"示":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"都":{"docs":{},"允":{"docs":{},"许":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"模":{"docs":{},"型":{"docs":{},"通":{"docs":{},"过":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"依":{"docs":{},"然":{"docs":{},"保":{"docs":{},"持":{"docs":{},"对":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"只":{"docs":{},"是":{"docs":{},"对":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"弱":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"当":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"变":{"docs":{},"量":{"docs":{},"所":{"docs":{},"保":{"docs":{},"持":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"也":{"docs":{},"有":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"向":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"数":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"会":{"docs":{},"在":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}},"，":{"docs":{},"这":{"docs":{},"也":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"你":{"docs":{},"不":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}},"类":{"docs":{},"开":{"docs":{},"始":{"docs":{},"，":{"docs":{},"并":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"此":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"为":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"并":{"docs":{},"打":{"docs":{},"印":{"docs":{},"出":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"以":{"docs":{},"表":{"docs":{},"明":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"程":{"docs":{},"生":{"docs":{},"效":{"docs":{},"。":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"了":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"1":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"1":{"docs":{},"到":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"类":{"docs":{},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"之":{"docs":{},"间":{"docs":{},"建":{"docs":{},"立":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"正":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"x":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}}}},"n":{"docs":{},"k":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0074211502782931356}}}}},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535}},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.005714285714285714}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}}}}}}}},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.012845849802371542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.015068493150684932}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"[":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.017857142857142856},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.04980842911877394}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414}}}},"封":{"docs":{},"装":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"。":{"docs":{},"如":{"docs":{},"代":{"docs":{},"码":{"docs":{},"所":{"docs":{},"示":{"docs":{},"，":{"docs":{},"它":{"docs":{},"正":{"docs":{},"确":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"(":{"5":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"元":{"docs":{},"组":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"变":{"docs":{},"异":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}},"（":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}},".":{"0":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}}},"1":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.01532567049808429}}},"docs":{}}}}},"w":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762}}}}},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.01054481546572935}},"并":{"docs":{},"移":{"docs":{},"除":{"docs":{},"值":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"c":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"该":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"将":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}}},"y":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.008893280632411068},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0061643835616438354}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01575757575757576},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.017142857142857144},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"l":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}},"(":{"docs":{},"\"":{"3":{"docs":{},"的":{"6":{"docs":{},"倍":{"docs":{},"是":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"6":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}},"r":{"docs":{},"e":{"docs":{},"'":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"a":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}}},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}},"d":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}},"b":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}},"t":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}},"h":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.01415929203539823},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0175054704595186},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.012919896640826873},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"e":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}},"s":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}},"r":{"docs":{},"e":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}},"\\":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},"'":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.013333333333333334}}}}}}},"e":{"docs":{},"w":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}},"m":{"docs":{},"m":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}},"u":{"docs":{},"n":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.022292993630573247}},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}},"p":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}},"e":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}},"'":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.007619047619047619}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}},"'":{"docs":{},"m":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}},"(":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}}},"docs":{},"\\":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}},"docs":{}}}}}}}}}}},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"0":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}}},"docs":{}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"l":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}},"q":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}},"w":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},"'":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.022292993630573247}}}}}}},"'":{"docs":{},"\\":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}},"docs":{}},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}},"docs":{}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}}}}}}},"d":{"1":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"docs":{}},"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}},"u":{"docs":{},"z":{"docs":{},"z":{"docs":{},"l":{"docs":{},"e":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},"!":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"(":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"y":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}},"docs":{}},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"i":{"docs":{},"s":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"0":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"9":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}}}}},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}},"“":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"输":{"docs":{},"出":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}},"（":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}},"的":{"docs":{},"输":{"docs":{},"入":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"并":{"docs":{},"对":{"docs":{},"其":{"docs":{},"字":{"docs":{},"符":{"docs":{},"进":{"docs":{},"行":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"。":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"，":{"docs":{},"考":{"docs":{},"虑":{"docs":{},"当":{"docs":{},"前":{"docs":{},"字":{"docs":{},"符":{"docs":{},"的":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"打":{"docs":{},"印":{"docs":{},"出":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"类":{"docs":{},"别":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"打":{"docs":{},"印":{"docs":{},"一":{"docs":{},"个":{"docs":{},"完":{"docs":{},"整":{"docs":{},"单":{"docs":{},"词":{"docs":{},"中":{"docs":{},"所":{"docs":{},"有":{"docs":{},"字":{"docs":{},"母":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"正":{"docs":{},"如":{"docs":{},"上":{"docs":{},"述":{"docs":{},"单":{"docs":{},"词":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"\"":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}},"v":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485}},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"!":{"docs":{},".":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"!":{"docs":{},".":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},".":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.031287605294825514},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.013927576601671309},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.016059957173447537},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"把":{"docs":{},"它":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"当":{"docs":{},"做":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}},"<":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0061643835616438354}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":5.015555555555555},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015}},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"构":{"docs":{},"造":{"docs":{},"过":{"docs":{},"程":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"，":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"和":{"docs":{},"协":{"docs":{},"议":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"）":{"docs":{},"修":{"docs":{},"改":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6666666666666665}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"）":{"docs":{},"还":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"）":{"docs":{},"提":{"docs":{},"供":{"docs":{},"自":{"docs":{},"己":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"（":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"把":{"docs":{},"这":{"docs":{},"种":{"docs":{},"行":{"docs":{},"为":{"docs":{},"叫":{"docs":{},"重":{"docs":{},"写":{"docs":{},"（":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"者":{"docs":{},"则":{"docs":{},"把":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"写":{"docs":{},"为":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"在":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"修":{"docs":{},"改":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.43478260869565216}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"是":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}},"，":{"docs":{},"也":{"docs":{},"能":{"docs":{},"够":{"docs":{},"要":{"docs":{},"求":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"(":{"docs":{},"设":{"docs":{},"置":{"docs":{},"权":{"docs":{},"限":{"docs":{},")":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}},"y":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334}},"e":{"docs":{},"的":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"它":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"元":{"docs":{},"组":{"docs":{},"值":{"docs":{},"(":{"8":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"（":{"docs":{},"这":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"不":{"docs":{},"会":{"docs":{},"定":{"docs":{},"义":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"是":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"类":{"docs":{},"型":{"docs":{},"所":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"何":{"docs":{},"种":{"docs":{},"信":{"docs":{},"息":{"docs":{},"的":{"docs":{},"别":{"docs":{},"名":{"docs":{},"）":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"如":{"docs":{},"此":{"docs":{},"，":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"别":{"docs":{},"名":{"docs":{},"支":{"docs":{},"持":{"docs":{},"一":{"docs":{},"种":{"docs":{},"方":{"docs":{},"法":{"docs":{},"识":{"docs":{},"别":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"里":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"种":{"docs":{},"使":{"docs":{},"用":{"docs":{},"在":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"中":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"保":{"docs":{},"证":{"docs":{},"任":{"docs":{},"何":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.007220216606498195},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.011131725417439703},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"存":{"docs":{},"在":{"docs":{},"时":{"docs":{},"，":{"docs":{},"将":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"插":{"docs":{},"入":{"docs":{},"到":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"之":{"docs":{},"前":{"docs":{},"来":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{},"构":{"docs":{},"建":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}},"）":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"二":{"docs":{},"元":{"docs":{},"（":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"）":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"主":{"docs":{},"要":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"）":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"和":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"）":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"。":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"运":{"docs":{},"行":{"docs":{},"某":{"docs":{},"些":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"同":{"docs":{},"时":{"docs":{},"，":{"docs":{},"也":{"docs":{},"需":{"docs":{},"要":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}},"z":{"docs":{},"z":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}}}}}}},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588}}}}}}},"s":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899}}}}}}},")":{"docs":{},"/":{"docs":{},"出":{"docs":{},"栈":{"docs":{},"(":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}},"n":{"docs":{},"e":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.03}},".":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"(":{"7":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"9":{"docs":{},")":{"docs":{},"语":{"docs":{},"句":{"docs":{},"获":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"可":{"docs":{},"选":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"获":{"docs":{},"得":{"docs":{},"，":{"docs":{},"把":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"该":{"docs":{},"可":{"docs":{},"选":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"内":{"docs":{},"容":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"范":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"无":{"docs":{},"法":{"docs":{},"检":{"docs":{},"索":{"docs":{},"到":{"docs":{},"位":{"docs":{},"置":{"docs":{},"为":{"9":{"docs":{},"的":{"docs":{},"行":{"docs":{},"星":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"是":{"2":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}}}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.07741935483870968}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}}},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"1":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"6":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}}},"类":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"来":{"docs":{},"监":{"docs":{},"测":{"docs":{},"这":{"docs":{},"个":{"docs":{},"用":{"docs":{},"户":{"docs":{},"的":{"docs":{},"发":{"docs":{},"展":{"docs":{},"进":{"docs":{},"度":{"docs":{},"。":{"docs":{},"他":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"完":{"docs":{},"成":{"docs":{},"某":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"等":{"docs":{},"级":{"docs":{},"就":{"docs":{},"调":{"docs":{},"用":{"docs":{},"它":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"解":{"docs":{},"锁":{"docs":{},"下":{"docs":{},"一":{"docs":{},"等":{"docs":{},"级":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"将":{"docs":{},"当":{"docs":{},"前":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"的":{"docs":{},"进":{"docs":{},"度":{"docs":{},"更":{"docs":{},"新":{"docs":{},"为":{"docs":{},"下":{"docs":{},"一":{"docs":{},"等":{"docs":{},"级":{"docs":{},"。":{"docs":{},"（":{"docs":{},"我":{"docs":{},"们":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"了":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"之":{"docs":{},"前":{"docs":{},"调":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"从":{"docs":{},"银":{"docs":{},"行":{"docs":{},"获":{"docs":{},"取":{"docs":{},"一":{"docs":{},"定":{"docs":{},"数":{"docs":{},"量":{"docs":{},"的":{"docs":{},"硬":{"docs":{},"币":{"docs":{},"，":{"docs":{},"并":{"docs":{},"把":{"docs":{},"它":{"docs":{},"们":{"docs":{},"添":{"docs":{},"加":{"docs":{},"到":{"docs":{},"玩":{"docs":{},"家":{"docs":{},"的":{"docs":{},"钱":{"docs":{},"包":{"docs":{},"。":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"还":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"析":{"docs":{},"构":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.025806451612903226}},"e":{"docs":{},"!":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"2":{"docs":{},"_":{"0":{"0":{"0":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"意":{"docs":{},"思":{"docs":{},"是":{"docs":{},"“":{"docs":{},"没":{"docs":{},"有":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"”":{"docs":{},"。":{"docs":{},"当":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"发":{"docs":{},"生":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"变":{"docs":{},"量":{"docs":{},"对":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"被":{"docs":{},"破":{"docs":{},"坏":{"docs":{},"了":{"docs":{},"。":{"docs":{},"没":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"引":{"docs":{},"用":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"感":{"docs":{},"叹":{"docs":{},"号":{"docs":{},"（":{"docs":{},"!":{"docs":{},"）":{"docs":{},"来":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"，":{"docs":{},"每":{"docs":{},"当":{"docs":{},"其":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"存":{"docs":{},"储":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}},"u":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"s":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}}}}}}}},">":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}},"<":{"docs":{},"/":{"docs":{},"p":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0547945205479452}}}}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"表":{"docs":{},"示":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"类":{"docs":{},"c":{"docs":{},"且":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"协":{"docs":{},"议":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.008484848484848486},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.03582089552238806}}},"2":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01090909090909091},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.03283582089552239}},")":{"docs":{},"，":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"在":{"docs":{},"新":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"s":{"1":{"docs":{},"应":{"docs":{},"该":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"2":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}},"docs":{}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"该":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"这":{"docs":{},"里":{"docs":{},"没":{"docs":{},"有":{"docs":{},"歧":{"docs":{},"义":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}},"g":{"5":{"5":{"2":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"docs":{}},"docs":{}},"docs":{}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"y":{"docs":{},"z":{"docs":{},"h":{"docs":{},"u":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}},"f":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.011131725417439703}}}}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.006857142857142857}},".":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"类":{"docs":{},"缺":{"docs":{},"少":{"docs":{},"了":{"docs":{},"一":{"docs":{},"些":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"东":{"docs":{},"西":{"docs":{},"：":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"类":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}}}},"o":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.030634573304157548}},"[":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475}}},"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"4":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"6":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}}}},"docs":{}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"(":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"“":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"“":{"docs":{},"，":{"docs":{},"记":{"docs":{},"作":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"由":{"docs":{},"两":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"（":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"创":{"docs":{},"建":{"docs":{},"）":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"现":{"docs":{},"在":{"docs":{},"只":{"docs":{},"有":{"5":{"docs":{},"项":{"docs":{},"，":{"docs":{},"不":{"docs":{},"包":{"docs":{},"括":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}},"docs":{}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.011029411764705883}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}},"没":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"来":{"docs":{},"为":{"docs":{},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"且":{"docs":{},"它":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"父":{"docs":{},"类":{"docs":{},"的":{"docs":{},"基":{"docs":{},"类":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"获":{"docs":{},"得":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"设":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"没":{"docs":{},"有":{"docs":{},"显":{"docs":{},"式":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"设":{"docs":{},"置":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"但":{"docs":{},"由":{"docs":{},"于":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"默":{"docs":{},"认":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"创":{"docs":{},"造":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"（":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"(":{"docs":{},")":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"语":{"docs":{},"法":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"将":{"docs":{},"其":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"变":{"docs":{},"量":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"封":{"docs":{},"装":{"docs":{},"了":{"docs":{},"购":{"docs":{},"物":{"docs":{},"清":{"docs":{},"单":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"一":{"docs":{},"项":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"：":{"docs":{},"名":{"docs":{},"字":{"docs":{},"（":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"、":{"docs":{},"数":{"docs":{},"量":{"docs":{},"（":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}},"i":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"u":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.012571428571428572}}}}}}}},"s":{"docs":{},")":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.014857142857142857}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"e":{"docs":{},"时":{"docs":{},"候":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"用":{"docs":{},"来":{"docs":{},"标":{"docs":{},"记":{"docs":{},"一":{"docs":{},"个":{"docs":{},"会":{"docs":{},"修":{"docs":{},"改":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"1":{"7":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}},"docs":{}},"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"<":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}},"x":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}},"e":{"docs":{},"g":{"docs":{},"g":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}},"z":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.013333333333333334},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.027573529411764705},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.02586206896551724}},"(":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}}}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"封":{"docs":{},"装":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5585406301824213}}}}}}}}}}}}}},"w":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"g":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.00927643784786642}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"z":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}},"r":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}},"，":{"3":{"1":{"0":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}},"docs":{}},"docs":{}},"docs":{}},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"两":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{},"类":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"p":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"类":{"docs":{},"将":{"docs":{},"f":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"实":{"docs":{},"现":{"docs":{},"为":{"docs":{},"可":{"docs":{},"读":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"它":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"都":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"的":{"docs":{},"必":{"docs":{},"备":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9205194805194806},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.017130620985010708},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.010273972602739725},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.1092436974789916}},"s":{"docs":{},"）":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9090909090909092}}}}}}}}}}}}}}},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"执":{"docs":{},"行":{"docs":{},"递":{"docs":{},"增":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"转":{"docs":{},"到":{"docs":{},"第":{"1":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}},"2":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}},"docs":{}}}}}}}},"-":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}}}}}}},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.02654867256637168}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}}}}},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}},"i":{"docs":{},"c":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.013333333333333334},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.01935483870967742},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"来":{"docs":{},"为":{"docs":{},"类":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"静":{"docs":{},"态":{"docs":{},"属":{"docs":{},"性":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"使":{"docs":{},"用":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"在":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"类":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"以":{"docs":{},"或":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"内":{"docs":{},"，":{"docs":{},"亦":{"docs":{},"或":{"docs":{},"是":{"docs":{},"以":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"d":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}}}}},"如":{"docs":{},"何":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}},"单":{"docs":{},"例":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"压":{"docs":{},"了":{"docs":{},"三":{"docs":{},"个":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"进":{"docs":{},"栈":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"也":{"docs":{},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"单":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"包":{"docs":{},"含":{"docs":{},"三":{"docs":{},"个":{"docs":{},"同":{"docs":{},"栈":{"docs":{},"里":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"即":{"docs":{},"便":{"docs":{},"栈":{"docs":{},"和":{"docs":{},"数":{"docs":{},"组":{"docs":{},"否":{"docs":{},"是":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"他":{"docs":{},"们":{"docs":{},"都":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"他":{"docs":{},"们":{"docs":{},"都":{"docs":{},"包":{"docs":{},"含":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"。":{"docs":{},"你":{"docs":{},"因":{"docs":{},"此":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"用":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"作":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"函":{"docs":{},"数":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"显":{"docs":{},"示":{"docs":{},"了":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"同":{"docs":{},"创":{"docs":{},"建":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"基":{"docs":{},"本":{"docs":{},"上":{"docs":{},"和":{"docs":{},"非":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"占":{"docs":{},"位":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"为":{"docs":{},"t":{"docs":{},"代":{"docs":{},"替":{"docs":{},"了":{"docs":{},"实":{"docs":{},"际":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"一":{"docs":{},"对":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"里":{"docs":{},"（":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"的":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"保":{"docs":{},"证":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"所":{"docs":{},"使":{"docs":{},"用":{"docs":{},"的":{"docs":{},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"后":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"将":{"docs":{},"任":{"docs":{},"何":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"当":{"docs":{},"作":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"栈":{"docs":{},"）":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"栈":{"docs":{},"是":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"值":{"docs":{},"域":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"，":{"docs":{},"和":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.007434944237918215}}},"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.027428571428571427},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.02654867256637168},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":2.0390334572490705},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.01312910284463895},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.05818181818181818},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.04776119402985075},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.02389705882352941},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.05333333333333334},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.022271714922048998},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.018050541516245487},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.01054481546572935},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.007905138339920948},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}},")":{"docs":{},"元":{"docs":{},"组":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"是":{"docs":{},"否":{"docs":{},"获":{"docs":{},"取":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{},"和":{"docs":{},"只":{"docs":{},"能":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"比":{"docs":{},"较":{"docs":{},"起":{"docs":{},"来":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"信":{"docs":{},"息":{"docs":{},"更":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"[":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"(":{"0":{"6":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"#":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"过":{"docs":{},"程":{"docs":{},"满":{"docs":{},"足":{"docs":{},"两":{"docs":{},"段":{"docs":{},"式":{"docs":{},"构":{"docs":{},"造":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"的":{"docs":{},"安":{"docs":{},"全":{"docs":{},"检":{"docs":{},"查":{"1":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"跟":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"中":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"给":{"docs":{},"参":{"docs":{},"数":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"传":{"docs":{},"值":{"docs":{},"[":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"是":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"依":{"docs":{},"然":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"对":{"docs":{},"所":{"docs":{},"有":{"docs":{},"父":{"docs":{},"类":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"能":{"docs":{},"确":{"docs":{},"保":{"docs":{},"所":{"docs":{},"有":{"docs":{},"新":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"中":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"类":{"docs":{},"没":{"docs":{},"有":{"docs":{},"父":{"docs":{},"类":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"通":{"docs":{},"过":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"假":{"docs":{},"设":{"docs":{},"任":{"docs":{},"意":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"为":{"1":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"显":{"docs":{},"示":{"docs":{},"指":{"docs":{},"明":{"docs":{},"数":{"docs":{},"量":{"docs":{},"即":{"docs":{},"可":{"docs":{},"创":{"docs":{},"建":{"docs":{},"出":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"可":{"docs":{},"以":{"docs":{},"让":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"更":{"docs":{},"加":{"docs":{},"方":{"docs":{},"便":{"docs":{},"和":{"docs":{},"快":{"docs":{},"捷":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"避":{"docs":{},"免":{"docs":{},"了":{"docs":{},"使":{"docs":{},"用":{"docs":{},"重":{"docs":{},"复":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"多":{"docs":{},"个":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"”":{"docs":{},"的":{"docs":{},"意":{"docs":{},"思":{"docs":{},"是":{"docs":{},"“":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"任":{"docs":{},"意":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"值":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"则":{"docs":{},"这":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"值":{"docs":{},"等":{"docs":{},"于":{"docs":{},"被":{"docs":{},"替":{"docs":{},"换":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"否":{"docs":{},"则":{"docs":{},"将":{"docs":{},"会":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"解":{"docs":{},"析":{"docs":{},"可":{"docs":{},"选":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"作":{"docs":{},"用":{"docs":{},"是":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"。":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"1":{"2":{"3":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"数":{"docs":{},"字":{"1":{"2":{"3":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"除":{"docs":{},"此":{"docs":{},"之":{"docs":{},"外":{"docs":{},"，":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"本":{"docs":{},"章":{"docs":{},"介":{"docs":{},"绍":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"您":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"任":{"docs":{},"意":{"docs":{},"要":{"docs":{},"求":{"docs":{},"传":{"docs":{},"入":{"docs":{},"n":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"空":{"docs":{},"字":{"docs":{},"典":{"docs":{},"来":{"docs":{},"储":{"docs":{},"存":{"docs":{},"英":{"docs":{},"语":{"docs":{},"对":{"docs":{},"整":{"docs":{},"数":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"。":{"docs":{},"他":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"他":{"docs":{},"们":{"docs":{},"对":{"docs":{},"应":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"一":{"docs":{},"个":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"键":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"）":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"构":{"docs":{},"造":{"docs":{},"两":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"的":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"变":{"docs":{},"量":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"并":{"docs":{},"且":{"docs":{},"给":{"docs":{},"它":{"docs":{},"设":{"docs":{},"置":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"。":{"docs":{},"函":{"docs":{},"数":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"当":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"属":{"docs":{},"于":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"质":{"docs":{},"数":{"docs":{},"之":{"docs":{},"一":{"docs":{},"时":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"段":{"docs":{},"文":{"docs":{},"字":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"后":{"docs":{},"，":{"docs":{},"来":{"docs":{},"表":{"docs":{},"明":{"docs":{},"这":{"docs":{},"个":{"docs":{},"是":{"docs":{},"数":{"docs":{},"字":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"质":{"docs":{},"数":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"它":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"来":{"docs":{},"“":{"docs":{},"贯":{"docs":{},"穿":{"docs":{},"”":{"docs":{},"到":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"。":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"分":{"docs":{},"支":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"段":{"docs":{},"额":{"docs":{},"外":{"docs":{},"的":{"docs":{},"文":{"docs":{},"字":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"最":{"docs":{},"后":{"docs":{},"，":{"docs":{},"至":{"docs":{},"此":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"互":{"docs":{},"相":{"docs":{},"交":{"docs":{},"换":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"一":{"docs":{},"定":{"docs":{},"要":{"docs":{},"做":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"进":{"docs":{},"行":{"docs":{},"排":{"docs":{},"序":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"排":{"docs":{},"序":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"需":{"docs":{},"为":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"特":{"docs":{},"定":{"docs":{},"序":{"docs":{},"列":{"docs":{},"的":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"可":{"docs":{},"以":{"docs":{},"理":{"docs":{},"解":{"docs":{},"为":{"docs":{},"“":{"docs":{},"一":{"docs":{},"个":{"docs":{},"没":{"docs":{},"有":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"你":{"docs":{},"绝":{"docs":{},"对":{"docs":{},"不":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"传":{"docs":{},"进":{"docs":{},"去":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"字":{"docs":{},"为":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"安":{"docs":{},"全":{"docs":{},"会":{"docs":{},"阻":{"docs":{},"止":{"docs":{},"你":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"和":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"请":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"为":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"方":{"docs":{},"法":{"docs":{},"命":{"docs":{},"名":{"docs":{},"（":{"docs":{},"如":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"以":{"docs":{},"表":{"docs":{},"明":{"docs":{},"存":{"docs":{},"储":{"docs":{},"映":{"docs":{},"射":{"docs":{},"值":{"docs":{},"的":{"docs":{},"新":{"docs":{},"数":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}}}}}}},"t":{"docs":{},"f":{"docs":{},"-":{"8":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}},"docs":{}},"docs":{}}}}}},"docs":{}}}}}}},"是":{"docs":{},"例":{"docs":{},"如":{"docs":{},"“":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}},"访":{"docs":{},"问":{"docs":{},"时":{"docs":{},"会":{"docs":{},"成":{"docs":{},"为":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"1":{"6":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},",":{"docs":{},"它":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"键":{"docs":{},"和":{"docs":{},"值":{"docs":{},"都":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}},"[":{"docs":{},"]":{"docs":{},"是":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}},"一":{"docs":{},"种":{"docs":{},"数":{"docs":{},"据":{"docs":{},"结":{"docs":{},"构":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}},"值":{"docs":{},"。":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"该":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"只":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"）":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"分":{"docs":{},"配":{"docs":{},"过":{"docs":{},"程":{"docs":{},"就":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"用":{"docs":{},"两":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"项":{"docs":{},"来":{"docs":{},"构":{"docs":{},"造":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"当":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"y":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"空":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}},"?":{"docs":{},"。":{"docs":{},"如":{"docs":{},"上":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"后":{"docs":{},"最":{"docs":{},"终":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"依":{"docs":{},"然":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.02},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.016544117647058824},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"u":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707}},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"在":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"前":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"两":{"docs":{},"层":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"，":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"也":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.007272727272727273}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}}}}}}}}}}}},"类":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.012919896640826873},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}},"r":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"k":{"docs":{},"a":{"docs":{},"m":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}},")":{"docs":{},"，":{"docs":{},"以":{"docs":{},"此":{"docs":{},"确":{"docs":{},"保":{"docs":{},"在":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"试":{"docs":{},"图":{"docs":{},"修":{"docs":{},"改":{"docs":{},"那":{"docs":{},"些":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"前":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"`":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.007326007326007326}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"超":{"docs":{},"类":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"正":{"docs":{},"如":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.007326007326007326}}}}},"`":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"[":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"e":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"[":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.06299212598425197}},".":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"r":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"对":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"返":{"docs":{},"回":{"docs":{},"“":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"”":{"docs":{},"，":{"docs":{},"对":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"返":{"docs":{},"回":{"docs":{},"“":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"四":{"docs":{},"种":{"docs":{},"花":{"docs":{},"色":{"docs":{},"，":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}},"o":{"docs":{},"f":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"(":{"4":{"2":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"）":{"docs":{},"变":{"docs":{},"成":{"docs":{},"父":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"超":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":10.005405405405405},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.005928853754940711},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.007494646680942184},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"可":{"docs":{},"以":{"docs":{},"重":{"docs":{},"写":{"docs":{},"（":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"）":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"来":{"docs":{},"优":{"docs":{},"化":{"docs":{},"或":{"docs":{},"修":{"docs":{},"改":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"去":{"docs":{},"替":{"docs":{},"换":{"docs":{},"这":{"docs":{},"一":{"docs":{},"范":{"docs":{},"围":{"docs":{},"内":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"数":{"docs":{},"组":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"确":{"docs":{},"要":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"数":{"docs":{},"组":{"docs":{},"内":{"docs":{},"容":{"docs":{},"的":{"docs":{},"行":{"docs":{},"为":{"docs":{},"规":{"docs":{},"则":{"docs":{},"与":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"键":{"docs":{},"值":{"docs":{},"的":{"docs":{},"相":{"docs":{},"同":{"docs":{},"，":{"docs":{},"参":{"docs":{},"见":{"docs":{},"章":{"docs":{},"节":{"docs":{},"[":{"docs":{},"集":{"docs":{},"合":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"与":{"docs":{},"复":{"docs":{},"制":{"docs":{},"行":{"docs":{},"为":{"docs":{},"]":{"docs":{},"(":{"docs":{},"#":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"_":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"_":{"docs":{},"b":{"docs":{},"e":{"docs":{},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.016216216216216217}}}}}}},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"，":{"docs":{},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"入":{"docs":{},"参":{"docs":{},"（":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"）":{"docs":{},"和":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"与":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"定":{"docs":{},"为":{"docs":{},"读":{"docs":{},"写":{"docs":{},"或":{"docs":{},"只":{"docs":{},"读":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"方":{"docs":{},"式":{"docs":{},"又":{"docs":{},"有":{"docs":{},"点":{"docs":{},"像":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"­":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"y":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"w":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}}},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"用":{"docs":{},"常":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"替":{"docs":{},"代":{"docs":{},"变":{"docs":{},"量":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"，":{"docs":{},"指":{"docs":{},"明":{"docs":{},"问":{"docs":{},"题":{"docs":{},"内":{"docs":{},"容":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"在":{"docs":{},"其":{"docs":{},"创":{"docs":{},"建":{"docs":{},"之":{"docs":{},"后":{"docs":{},"不":{"docs":{},"会":{"docs":{},"再":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"属":{"docs":{},"性":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526}}}}}},"e":{"docs":{},"d":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.06},"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":10.372093023255815},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":10.005714285714285},"chapter1/chapter1.html#gitbook_6470":{"ref":"chapter1/chapter1.html#gitbook_6470","tf":10.75},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.06548672566371681},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.026022304832713755},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.04814004376367615},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.012380952380952381},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01090909090909091},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.03582089552238806},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.02},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.03359173126614987},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.017857142857142856},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.041463414634146344},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.02022058823529412},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.009523809523809525},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.028119507908611598},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.011131725417439703},"chapter2/chapter2.html#gitbook_6516":{"ref":"chapter2/chapter2.html#gitbook_6516","tf":10.666666666666666},"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.07407407407407407},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.016713091922005572},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.005928853754940711},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0196078431372549}},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"这":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"类":{"docs":{},"型":{"docs":{},"安":{"docs":{},"全":{"docs":{},"和":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"给":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"赋":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"变":{"docs":{},"量":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"内":{"docs":{},"建":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"下":{"docs":{},"标":{"docs":{},"。":{"docs":{},"该":{"docs":{},"下":{"docs":{},"标":{"docs":{},"[":{"docs":{},"n":{"docs":{},"]":{"docs":{},"返":{"docs":{},"回":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"数":{"docs":{},"字":{"docs":{},"从":{"docs":{},"右":{"docs":{},"向":{"docs":{},"左":{"docs":{},"数":{"docs":{},"的":{"docs":{},"第":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"已":{"docs":{},"经":{"docs":{},"提":{"docs":{},"供":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"通":{"docs":{},"过":{"docs":{},"下":{"docs":{},"标":{"docs":{},"来":{"docs":{},"查":{"docs":{},"找":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"功":{"docs":{},"能":{"docs":{},"都":{"docs":{},"达":{"docs":{},"到":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"去":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"简":{"docs":{},"单":{"docs":{},"声":{"docs":{},"明":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"而":{"docs":{},"已":{"docs":{},"。":{"docs":{},"如":{"docs":{},"何":{"docs":{},"实":{"docs":{},"践":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"，":{"docs":{},"在":{"docs":{},"[":{"docs":{},"使":{"docs":{},"用":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"采":{"docs":{},"纳":{"docs":{},"]":{"docs":{},"[":{"7":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"较":{"docs":{},"c":{"docs":{},"语":{"docs":{},"言":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"来":{"docs":{},"得":{"docs":{},"更":{"docs":{},"简":{"docs":{},"单":{"docs":{},"和":{"docs":{},"保":{"docs":{},"守":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"跟":{"docs":{},"基":{"docs":{},"于":{"docs":{},"c":{"docs":{},"的":{"docs":{},"语":{"docs":{},"言":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"一":{"docs":{},"样":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"在":{"docs":{},"移":{"docs":{},"植":{"docs":{},"已":{"docs":{},"有":{"docs":{},"代":{"docs":{},"码":{"docs":{},"到":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"考":{"docs":{},"，":{"docs":{},"你":{"docs":{},"不":{"docs":{},"用":{"docs":{},"在":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"定":{"docs":{},"义":{"docs":{},"部":{"docs":{},"分":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"。":{"docs":{},"由":{"docs":{},"于":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"通":{"docs":{},"过":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"查":{"docs":{},"找":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"推":{"docs":{},"断":{"docs":{},"出":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"并":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"。":{"docs":{},"此":{"docs":{},"处":{"docs":{},"为":{"docs":{},"了":{"docs":{},"演":{"docs":{},"示":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"让":{"docs":{},"+":{"docs":{},"+":{"docs":{},"+":{"docs":{},"对":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"支":{"docs":{},"持":{"docs":{},"如":{"docs":{},"下":{"docs":{},"所":{"docs":{},"有":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}},"还":{"docs":{},"有":{"docs":{},"许":{"docs":{},"多":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"高":{"docs":{},"级":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"了":{"docs":{},"c":{"docs":{},"语":{"docs":{},"和":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"有":{"docs":{},"两":{"docs":{},"类":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"以":{"docs":{},"及":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"当":{"docs":{},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"或":{"docs":{},"便":{"docs":{},"利":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"，":{"docs":{},"表":{"docs":{},"明":{"docs":{},"它":{"docs":{},"的":{"docs":{},"每":{"docs":{},"个":{"docs":{},"子":{"docs":{},"类":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"实":{"docs":{},"现":{"docs":{},"那":{"docs":{},"个":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"。":{"docs":{},"再":{"docs":{},"比":{"docs":{},"如":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"信":{"docs":{},"息":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"反":{"docs":{},"方":{"docs":{},"向":{"docs":{},"流":{"docs":{},"动":{"docs":{},"—":{"docs":{},"—":{"docs":{},"从":{"docs":{},"根":{"docs":{},"节":{"docs":{},"点":{"docs":{},"传":{"docs":{},"向":{"docs":{},"叶":{"docs":{},"子":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"常":{"docs":{},"量":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"上":{"docs":{},"的":{"docs":{},"显":{"docs":{},"式":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"解":{"docs":{},"（":{"docs":{},":":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"）":{"docs":{},"导":{"docs":{},"致":{"docs":{},"数":{"docs":{},"字":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"2":{"docs":{},".":{"7":{"1":{"8":{"2":{"8":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"而":{"docs":{},"非":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"常":{"docs":{},"量":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"在":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"左":{"docs":{},"侧":{"docs":{},"）":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"语":{"docs":{},"句":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"在":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"标":{"docs":{},"签":{"docs":{},"）":{"docs":{},"中":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"任":{"docs":{},"何":{"docs":{},"模":{"docs":{},"式":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"标":{"docs":{},"签":{"docs":{},"中":{"docs":{},"，":{"docs":{},"但":{"docs":{},"在":{"docs":{},"其":{"docs":{},"他":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"通":{"docs":{},"配":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"言":{"docs":{},"相":{"docs":{},"对":{"docs":{},"小":{"docs":{},"点":{"docs":{},"，":{"docs":{},"这":{"docs":{},"是":{"docs":{},"由":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"几":{"docs":{},"乎":{"docs":{},"无":{"docs":{},"处":{"docs":{},"不":{"docs":{},"在":{"docs":{},"的":{"docs":{},"许":{"docs":{},"多":{"docs":{},"常":{"docs":{},"见":{"docs":{},"的":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"以":{"docs":{},"及":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"都":{"docs":{},"由":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"虽":{"docs":{},"然":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"和":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"紧":{"docs":{},"接":{"docs":{},"中":{"docs":{},"括":{"docs":{},"号":{"docs":{},"[":{"docs":{},"]":{"docs":{},"来":{"docs":{},"简":{"docs":{},"化":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"!":{"docs":{},"作":{"docs":{},"为":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"命":{"docs":{},"名":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"l":{"docs":{},"y":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"?":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"广":{"docs":{},"泛":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"断":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"允":{"docs":{},"许":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"很":{"docs":{},"多":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"或":{"docs":{},"部":{"docs":{},"分":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"细":{"docs":{},"节":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"见":{"docs":{},"章":{"docs":{},"节":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"与":{"docs":{},"输":{"docs":{},"入":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"进":{"docs":{},"行":{"docs":{},"比":{"docs":{},"较":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"则":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"~":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"使":{"docs":{},"用":{"docs":{},"=":{"docs":{},"=":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"来":{"docs":{},"比":{"docs":{},"较":{"docs":{},"两":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"它":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"与":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.02761904761904762},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.03666666666666667},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":2.241830065359477}},"中":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"的":{"docs":{},"子":{"docs":{},"句":{"docs":{},"之":{"docs":{},"后":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"会":{"docs":{},"退":{"docs":{},"出":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"向":{"docs":{},"下":{"docs":{},"运":{"docs":{},"行":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"每":{"docs":{},"个":{"docs":{},"子":{"docs":{},"句":{"docs":{},"结":{"docs":{},"尾":{"docs":{},"写":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"立":{"docs":{},"即":{"docs":{},"中":{"docs":{},"断":{"docs":{},"该":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"跳":{"docs":{},"转":{"docs":{},"到":{"docs":{},"表":{"docs":{},"示":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"嵌":{"docs":{},"套":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"来":{"docs":{},"创":{"docs":{},"造":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"两":{"docs":{},"者":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"来":{"docs":{},"提":{"docs":{},"前":{"docs":{},"结":{"docs":{},"束":{"docs":{},"整":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"体":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"显":{"docs":{},"示":{"docs":{},"地":{"docs":{},"指":{"docs":{},"明":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"想":{"docs":{},"要":{"docs":{},"终":{"docs":{},"止":{"docs":{},"的":{"docs":{},"是":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"，":{"docs":{},"会":{"docs":{},"很":{"docs":{},"有":{"docs":{},"用":{"docs":{},"。":{"docs":{},"类":{"docs":{},"似":{"docs":{},"地":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"有":{"docs":{},"许":{"docs":{},"多":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"，":{"docs":{},"显":{"docs":{},"示":{"docs":{},"指":{"docs":{},"明":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"完":{"docs":{},"成":{"docs":{},"了":{"docs":{},"它":{"docs":{},"的":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"相":{"docs":{},"比":{"docs":{},"之":{"docs":{},"下":{"docs":{},"，":{"docs":{},"c":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}},"执":{"docs":{},"行":{"docs":{},"完":{"docs":{},"后":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"打":{"docs":{},"印":{"docs":{},"该":{"docs":{},"数":{"docs":{},"字":{"docs":{},"的":{"docs":{},"描":{"docs":{},"述":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"数":{"docs":{},"字":{"5":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"接":{"docs":{},"下":{"docs":{},"来":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"通":{"docs":{},"过":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"是":{"docs":{},"否":{"docs":{},"曾":{"docs":{},"经":{"docs":{},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"过":{"docs":{},"值":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"缘":{"docs":{},"故":{"docs":{},"，":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"曾":{"docs":{},"被":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"当":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"或":{"docs":{},"者":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"支":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"包":{"docs":{},"含":{"docs":{},"注":{"docs":{},"释":{"docs":{},"时":{"docs":{},"，":{"docs":{},"会":{"docs":{},"被":{"docs":{},"报":{"docs":{},"编":{"docs":{},"译":{"docs":{},"时":{"docs":{},"错":{"docs":{},"误":{"docs":{},"。":{"docs":{},"注":{"docs":{},"释":{"docs":{},"不":{"docs":{},"是":{"docs":{},"代":{"docs":{},"码":{"docs":{},"语":{"docs":{},"句":{"docs":{},"而":{"docs":{},"且":{"docs":{},"也":{"docs":{},"不":{"docs":{},"能":{"docs":{},"让":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"达":{"docs":{},"到":{"docs":{},"被":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"的":{"docs":{},"效":{"docs":{},"果":{"docs":{},"。":{"docs":{},"你":{"docs":{},"总":{"docs":{},"是":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"不":{"docs":{},"会":{"docs":{},"同":{"docs":{},"时":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"的":{"docs":{},"，":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"会":{"docs":{},"引":{"docs":{},"起":{"docs":{},"编":{"docs":{},"译":{"docs":{},"期":{"docs":{},"错":{"docs":{},"误":{"docs":{},"：":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"测":{"docs":{},"试":{"docs":{},"多":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"元":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"值":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"区":{"docs":{},"间":{"docs":{},"。":{"docs":{},"另":{"docs":{},"外":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"下":{"docs":{},"划":{"docs":{},"线":{"docs":{},"（":{"docs":{},"_":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}}}}},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"修":{"docs":{},"改":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"和":{"docs":{},"书":{"docs":{},"写":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"的":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"保":{"docs":{},"持":{"docs":{},"一":{"docs":{},"致":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"当":{"docs":{},"多":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"含":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"值":{"docs":{},"且":{"docs":{},"能":{"docs":{},"够":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"程":{"docs":{},"序":{"docs":{},"只":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"源":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"值":{"docs":{},"都":{"docs":{},"必":{"docs":{},"须":{"docs":{},"至":{"docs":{},"少":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"与":{"docs":{},"之":{"docs":{},"对":{"docs":{},"应":{"docs":{},"。":{"docs":{},"在":{"docs":{},"某":{"docs":{},"些":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"（":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"会":{"docs":{},"判":{"docs":{},"断":{"docs":{},"某":{"docs":{},"个":{"docs":{},"点":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"红":{"docs":{},"色":{"docs":{},"的":{"docs":{},"x":{"docs":{},"轴":{"docs":{},"上":{"docs":{},"，":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"黄":{"docs":{},"色":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}},"绿":{"docs":{},"色":{"docs":{},"的":{"docs":{},"对":{"docs":{},"角":{"docs":{},"线":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}},"是":{"docs":{},"原":{"docs":{},"点":{"docs":{},"(":{"0":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"docs":{}}}}}}}}}}}},"尝":{"docs":{},"试":{"docs":{},"把":{"docs":{},"某":{"docs":{},"个":{"docs":{},"值":{"docs":{},"与":{"docs":{},"若":{"docs":{},"干":{"docs":{},"个":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"）":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"。":{"docs":{},"根":{"docs":{},"据":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"的":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"。":{"docs":{},"当":{"docs":{},"有":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"较":{"docs":{},"多":{"docs":{},"时":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"替":{"docs":{},"换":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"值":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}},"包":{"docs":{},"含":{"docs":{},"关":{"docs":{},"联":{"docs":{},"值":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"案":{"docs":{},"例":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"阅":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}},"检":{"docs":{},"验":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"事":{"docs":{},"件":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"正":{"docs":{},"如":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"值":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"强":{"docs":{},"制":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"操":{"docs":{},"作":{"docs":{},"符":{"docs":{},"（":{"docs":{},"a":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}}}}}}}}}},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"包":{"docs":{},"含":{"docs":{},"默":{"docs":{},"认":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},")":{"docs":{},"块":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"其":{"docs":{},"它":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"块":{"docs":{},"都":{"docs":{},"无":{"docs":{},"法":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"控":{"docs":{},"制":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"中":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"只":{"docs":{},"能":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"块":{"docs":{},"，":{"docs":{},"而":{"docs":{},"且":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"，":{"docs":{},"它":{"docs":{},"由":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"和":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"其":{"docs":{},"后":{"docs":{},"的":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"(":{"docs":{},":":{"docs":{},")":{"docs":{},"组":{"docs":{},"成":{"docs":{},"。":{"docs":{},"在":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"e":{"docs":{},"后":{"docs":{},"面":{"docs":{},"跟":{"docs":{},"上":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"可":{"docs":{},"以":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"语":{"docs":{},"句":{"docs":{},"或":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"更":{"docs":{},"改":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"，":{"docs":{},"把":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"指":{"docs":{},"定":{"docs":{},"标":{"docs":{},"签":{"docs":{},"标":{"docs":{},"记":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"这":{"docs":{},"两":{"docs":{},"条":{"docs":{},"语":{"docs":{},"句":{"docs":{},"用":{"docs":{},"法":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"分":{"docs":{},"支":{"docs":{},"而":{"docs":{},"且":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"有":{"docs":{},"为":{"docs":{},"空":{"docs":{},"的":{"docs":{},"分":{"docs":{},"支":{"docs":{},"，":{"docs":{},"有":{"docs":{},"时":{"docs":{},"为":{"docs":{},"了":{"docs":{},"使":{"docs":{},"你":{"docs":{},"的":{"docs":{},"意":{"docs":{},"图":{"docs":{},"更":{"docs":{},"明":{"docs":{},"显":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"特":{"docs":{},"意":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"或":{"docs":{},"者":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"某":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"。":{"docs":{},"那":{"docs":{},"么":{"docs":{},"当":{"docs":{},"你":{"docs":{},"想":{"docs":{},"忽":{"docs":{},"略":{"docs":{},"某":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"该":{"docs":{},"分":{"docs":{},"支":{"docs":{},"内":{"docs":{},"写":{"docs":{},"上":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"当":{"docs":{},"那":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"时":{"docs":{},"，":{"docs":{},"分":{"docs":{},"支":{"docs":{},"内":{"docs":{},"的":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"语":{"docs":{},"句":{"docs":{},"立":{"docs":{},"即":{"docs":{},"结":{"docs":{},"束":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.01680672268907563}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}}},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"（":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}},"s":{"docs":{},"(":{"docs":{},"&":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"注":{"docs":{},"意":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}},",":{"docs":{},"用":{"docs":{},"来":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"可":{"docs":{},"以":{"docs":{},"交":{"docs":{},"换":{"docs":{},"b":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"到":{"docs":{},"a":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"交":{"docs":{},"换":{"docs":{},"a":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"到":{"docs":{},"b":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"非":{"docs":{},"常":{"docs":{},"有":{"docs":{},"用":{"docs":{},"的":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"它":{"docs":{},"只":{"docs":{},"能":{"docs":{},"交":{"docs":{},"换":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"要":{"docs":{},"交":{"docs":{},"换":{"docs":{},"两":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"或":{"docs":{},"者":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"函":{"docs":{},"数":{"docs":{},"功":{"docs":{},"能":{"docs":{},"都":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"，":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"不":{"docs":{},"同":{"docs":{},"之":{"docs":{},"处":{"docs":{},"就":{"docs":{},"在":{"docs":{},"于":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"&":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}},"<":{"docs":{},"t":{"docs":{},">":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"占":{"docs":{},"位":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"是":{"docs":{},"一":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"。":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"并":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"占":{"docs":{},"位":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"名":{"docs":{},"后":{"docs":{},"面":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"对":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"（":{"docs":{},"如":{"docs":{},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"）":{"docs":{},"，":{"docs":{},"或":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"或":{"docs":{},"用":{"docs":{},"作":{"docs":{},"函":{"docs":{},"数":{"docs":{},"主":{"docs":{},"体":{"docs":{},"中":{"docs":{},"的":{"docs":{},"注":{"docs":{},"释":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"被":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"所":{"docs":{},"代":{"docs":{},"表":{"docs":{},"的":{"docs":{},"占":{"docs":{},"位":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"管":{"docs":{},"函":{"docs":{},"数":{"docs":{},"任":{"docs":{},"何":{"docs":{},"时":{"docs":{},"候":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"所":{"docs":{},"替":{"docs":{},"换":{"docs":{},"（":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"当":{"docs":{},"函":{"docs":{},"数":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"t":{"docs":{},"被":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"替":{"docs":{},"换":{"docs":{},"，":{"docs":{},"第":{"docs":{},"二":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"被":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"主":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"行":{"docs":{},"稍":{"docs":{},"微":{"docs":{},"有":{"docs":{},"那":{"docs":{},"么":{"docs":{},"一":{"docs":{},"点":{"docs":{},"点":{"docs":{},"不":{"docs":{},"同":{"docs":{},"于":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"已":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"交":{"docs":{},"换":{"docs":{},"函":{"docs":{},"数":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}},"除":{"docs":{},"了":{"docs":{},"要":{"docs":{},"求":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"值":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"外":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"。":{"docs":{},"每":{"docs":{},"次":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"，":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"受":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"函":{"docs":{},"数":{"docs":{},"启":{"docs":{},"发":{"docs":{},"而":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"或":{"docs":{},"一":{"docs":{},"个":{"docs":{},"存":{"docs":{},"储":{"docs":{},"单":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"集":{"docs":{},"，":{"docs":{},"如":{"docs":{},"数":{"docs":{},"组":{"docs":{},"）":{"docs":{},"，":{"docs":{},"通":{"docs":{},"常":{"docs":{},"用":{"docs":{},"一":{"docs":{},"单":{"docs":{},"个":{"docs":{},"字":{"docs":{},"母":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"为":{"docs":{},"整":{"docs":{},"型":{"docs":{},"计":{"docs":{},"算":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"5":{"docs":{},"个":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}},"docs":{}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"w":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}},"m":{"docs":{},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.015503875968992248},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}},"y":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"a":{"docs":{},"v":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485}},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"展":{"docs":{},"示":{"docs":{},"的":{"docs":{},"是":{"docs":{},"用":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}}}},"t":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2912904938927244},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}},"r":{"docs":{},"f":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.03531598513011153}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"a":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"'":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.05511811023622047},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}}}}},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"l":{"docs":{},"f":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.8925244010647737},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.009523809523809525},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.02586206896551724},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.356685293716778},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.004794520547945206}},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.01904761904761905},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}},"e":{"docs":{},")":{"docs":{},">":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},"<":{"docs":{},"/":{"docs":{},"\\":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}},"z":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{},"了":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"r":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"c":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"b":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}},"在":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"引":{"docs":{},"用":{"docs":{},"其":{"docs":{},"它":{"docs":{},"的":{"docs":{},"属":{"docs":{},"于":{"docs":{},"相":{"docs":{},"同":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"。":{"docs":{},"并":{"docs":{},"且":{"docs":{},"你":{"docs":{},"只":{"docs":{},"能":{"docs":{},"在":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"内":{"docs":{},"部":{"docs":{},"调":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"n":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}}},"a":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"区":{"docs":{},"别":{"docs":{},"实":{"docs":{},"例":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"像":{"docs":{},"传":{"docs":{},"入":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"一":{"docs":{},"样":{"docs":{},"给":{"docs":{},"类":{"docs":{},"传":{"docs":{},"入":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"每":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"需":{"docs":{},"要":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"—":{"docs":{},"—":{"docs":{},"无":{"docs":{},"论":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"就":{"docs":{},"像":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"）":{"docs":{},"还":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"就":{"docs":{},"像":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"不":{"docs":{},"论":{"docs":{},"何":{"docs":{},"时":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"已":{"docs":{},"知":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"没":{"docs":{},"有":{"docs":{},"明":{"docs":{},"确":{"docs":{},"的":{"docs":{},"写":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"一":{"docs":{},"个":{"docs":{},"全":{"docs":{},"新":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"上":{"docs":{},"面":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}},"前":{"docs":{},"缀":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"(":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}},"消":{"docs":{},"除":{"docs":{},"方":{"docs":{},"法":{"docs":{},"参":{"docs":{},"数":{"docs":{},"x":{"docs":{},"和":{"docs":{},"实":{"docs":{},"例":{"docs":{},"属":{"docs":{},"性":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}},"赋":{"docs":{},"值":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"完":{"docs":{},"全":{"docs":{},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"隐":{"docs":{},"含":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"它":{"docs":{},"只":{"docs":{},"占":{"docs":{},"有":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"持":{"docs":{},"有":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"将":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"h":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"“":{"docs":{},"用":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"来":{"docs":{},"占":{"docs":{},"有":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"产":{"docs":{},"生":{"docs":{},"一":{"docs":{},"个":{"docs":{},"循":{"docs":{},"环":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"。":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"，":{"docs":{},"就":{"docs":{},"要":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"（":{"docs":{},"而":{"docs":{},"不":{"docs":{},"只":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"或":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"提":{"docs":{},"醒":{"docs":{},"你":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"不":{"docs":{},"小":{"docs":{},"心":{"docs":{},"就":{"docs":{},"占":{"docs":{},"有":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"其":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"必":{"docs":{},"须":{"docs":{},"将":{"docs":{},"该":{"docs":{},"实":{"docs":{},"例":{"docs":{},"方":{"docs":{},"法":{"docs":{},"标":{"docs":{},"注":{"docs":{},"为":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"，":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"返":{"docs":{},"回":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"本":{"docs":{},"身":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"适":{"docs":{},"配":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"还":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"使":{"docs":{},"用":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}},"[":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"[":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"等":{"docs":{},"同":{"docs":{},"于":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"修":{"docs":{},"饰":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"方":{"docs":{},"法":{"docs":{},"必":{"docs":{},"须":{"docs":{},"以":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"些":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}},"r":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"6":{"docs":{},":":{"0":{"0":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02564102564102564},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":5.017777777777778},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"与":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"副":{"docs":{},"本":{"docs":{},"合":{"docs":{},"成":{"docs":{},"，":{"docs":{},"由":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"属":{"docs":{},"性":{"docs":{},"本":{"docs":{},"身":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"该":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"需":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"n":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.07407407407407407},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.07407407407407407}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"名":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"正":{"docs":{},"如":{"docs":{},"在":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"声":{"docs":{},"明":{"docs":{},"速":{"docs":{},"记":{"docs":{},"(":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"写":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"，":{"docs":{},"它":{"docs":{},"就":{"docs":{},"会":{"docs":{},"作":{"docs":{},"为":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"不":{"docs":{},"写":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"封":{"docs":{},"闭":{"docs":{},"的":{"docs":{},"括":{"docs":{},"号":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"被":{"docs":{},"当":{"docs":{},"做":{"docs":{},"传":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"传":{"docs":{},"给":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"名":{"docs":{},"称":{"docs":{},"默":{"docs":{},"认":{"docs":{},"是":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"。":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"称":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"与":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"必":{"docs":{},"需":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}},"u":{"docs":{},"p":{"docs":{},")":{"docs":{},"被":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"类":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"被":{"docs":{},"转":{"docs":{},"移":{"docs":{},"到":{"docs":{},"了":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"0":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}},"docs":{}},"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"e":{"docs":{},"r":{"docs":{},"。":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"1":{"docs":{},"，":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"c":{"2":{"docs":{},"。":{"docs":{},"c":{"1":{"docs":{},"和":{"docs":{},"c":{"2":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"1":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"的":{"docs":{},"重":{"docs":{},"写":{"docs":{},"实":{"docs":{},"现":{"docs":{},"中":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{},"来":{"docs":{},"调":{"docs":{},"用":{"docs":{},"超":{"docs":{},"类":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},">":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}},".":{"1":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}},"docs":{},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"x":{"docs":{},"(":{"1":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"x":{"docs":{},"(":{"2":{"docs":{},".":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}},"docs":{}}}}}}}}},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.016666666666666666}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}}}}}}}},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.011142061281337047},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}}}}}}}}},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"变":{"docs":{},"量":{"docs":{},"通":{"docs":{},"过":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"进":{"docs":{},"行":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"等":{"docs":{},"）":{"docs":{},"，":{"docs":{},"以":{"docs":{},"便":{"docs":{},"符":{"docs":{},"合":{"docs":{},"标":{"docs":{},"准":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.012919896640826873}},"e":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"这":{"docs":{},"个":{"docs":{},"子":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"以":{"docs":{},"上":{"docs":{},"操":{"docs":{},"作":{"docs":{},"并":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"从":{"docs":{},"新":{"docs":{},"设":{"docs":{},"置":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"e":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"4":{"2":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"?":{"docs":{},"(":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"可":{"docs":{},"选":{"docs":{},"方":{"docs":{},"法":{"docs":{},"名":{"docs":{},"称":{"docs":{},"后":{"docs":{},"加":{"docs":{},"上":{"docs":{},"?":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"该":{"docs":{},"方":{"docs":{},"法":{"docs":{},"是":{"docs":{},"否":{"docs":{},"被":{"docs":{},"实":{"docs":{},"现":{"docs":{},"。":{"docs":{},"可":{"docs":{},"选":{"docs":{},"方":{"docs":{},"法":{"docs":{},"和":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"为":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.008620689655172414},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"指":{"docs":{},"定":{"docs":{},"为":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}},"：":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.008787346221441126}},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}}}}}}}},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}},"被":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"[":{"docs":{},"]":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}},"（":{"docs":{},"x":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}}},"e":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"引":{"docs":{},"用":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}},"都":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"[":{"docs":{},"]":{"docs":{},"获":{"docs":{},"取":{"docs":{},"访":{"docs":{},"问":{"docs":{},"：":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{},"是":{"docs":{},"指":{"docs":{},"第":{"0":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"“":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"[":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}},"u":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}},"s":{"docs":{},"和":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"在":{"docs":{},"不":{"docs":{},"同":{"docs":{},"位":{"docs":{},"上":{"docs":{},"有":{"1":{"docs":{},"。":{"docs":{},"按":{"docs":{},"位":{"docs":{},"或":{"docs":{},"运":{"docs":{},"行":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"0":{"docs":{},"，":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"2":{"5":{"4":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.011142061281337047},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.579436152570481}},"(":{"docs":{},"[":{"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.023880597014925373}}}}}},"函":{"docs":{},"数":{"docs":{},"对":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}},"当":{"docs":{},"排":{"docs":{},"序":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"排":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"面":{"docs":{},"还":{"docs":{},"是":{"docs":{},"后":{"docs":{},"面":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"值":{"docs":{},"前":{"docs":{},"面":{"docs":{},"，":{"docs":{},"排":{"docs":{},"序":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"函":{"docs":{},"数":{"docs":{},"需":{"docs":{},"要":{"docs":{},"返":{"docs":{},"回":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"反":{"docs":{},"之":{"docs":{},"返":{"docs":{},"回":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"进":{"docs":{},"行":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}},"整":{"docs":{},"体":{"docs":{},"调":{"docs":{},"用":{"docs":{},"保":{"docs":{},"持":{"docs":{},"不":{"docs":{},"变":{"docs":{},"，":{"docs":{},"一":{"docs":{},"对":{"docs":{},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"包":{"docs":{},"裹":{"docs":{},"住":{"docs":{},"了":{"docs":{},"函":{"docs":{},"数":{"docs":{},"中":{"docs":{},"整":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{},"而":{"docs":{},"其":{"docs":{},"中":{"docs":{},"一":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"现":{"docs":{},"在":{"docs":{},"变":{"docs":{},"成":{"docs":{},"了":{"docs":{},"内":{"docs":{},"联":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"（":{"docs":{},"相":{"docs":{},"比":{"docs":{},"于":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"明":{"docs":{},"确":{"docs":{},"了":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"必":{"docs":{},"须":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"期":{"docs":{},"望":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"是":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}},"u":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"t":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"n":{"docs":{},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.042316258351893093}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599}},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"计":{"docs":{},"算":{"docs":{},"数":{"docs":{},"组":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}},"检":{"docs":{},"查":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"，":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992}}}},"r":{"docs":{},"k":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}},"）":{"docs":{},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"2":{"0":{"docs":{},"）":{"docs":{},"、":{"docs":{},"换":{"docs":{},"行":{"docs":{},"符":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.014652014652014652}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099}},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"时":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"会":{"docs":{},"去":{"docs":{},"检":{"docs":{},"查":{"docs":{},"新":{"docs":{},"值":{"docs":{},"与":{"docs":{},"限":{"docs":{},"制":{"docs":{},"值":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"的":{"docs":{},"大":{"docs":{},"小":{"docs":{},"，":{"docs":{},"它":{"docs":{},"会":{"docs":{},"将":{"docs":{},"超":{"docs":{},"类":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"和":{"4":{"0":{"docs":{},".":{"0":{"docs":{},"中":{"docs":{},"较":{"docs":{},"小":{"docs":{},"的":{"docs":{},"那":{"docs":{},"个":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"哪":{"docs":{},"个":{"docs":{},"较":{"docs":{},"小":{"docs":{},"由":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"决":{"docs":{},"定":{"docs":{},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"标":{"docs":{},"准":{"docs":{},"库":{"docs":{},"中":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"全":{"docs":{},"局":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"置":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"大":{"docs":{},"于":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"的":{"docs":{},"数":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"打":{"docs":{},"印":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"出":{"docs":{},"，":{"docs":{},"你":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"速":{"docs":{},"度":{"docs":{},"被":{"docs":{},"限":{"docs":{},"制":{"docs":{},"在":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"。":{"docs":{},"类":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"表":{"docs":{},"示":{"docs":{},"安":{"docs":{},"装":{"docs":{},"了":{"docs":{},"限":{"docs":{},"速":{"docs":{},"装":{"docs":{},"置":{"docs":{},"的":{"docs":{},"车":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"最":{"docs":{},"高":{"docs":{},"速":{"docs":{},"度":{"docs":{},"只":{"docs":{},"能":{"docs":{},"达":{"docs":{},"到":{"4":{"0":{"docs":{},"m":{"docs":{},"p":{"docs":{},"h":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"重":{"docs":{},"写":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"和":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"替":{"docs":{},"换":{"docs":{},"为":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"b":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.011428571428571429},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.01619047619047619},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.012033694344163659}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}},"增":{"docs":{},"加":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"]":{"docs":{},"的":{"docs":{},"值":{"docs":{},"向":{"docs":{},"前":{"docs":{},"或":{"docs":{},"向":{"docs":{},"后":{"docs":{},"移":{"docs":{},"动":{"docs":{},"（":{"docs":{},"遇":{"docs":{},"到":{"docs":{},"了":{"docs":{},"梯":{"docs":{},"子":{"docs":{},"或":{"docs":{},"者":{"docs":{},"蛇":{"docs":{},"）":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"检":{"docs":{},"测":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"否":{"docs":{},"小":{"docs":{},"于":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"点":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"原":{"docs":{},"点":{"docs":{},"是":{"docs":{},"(":{"0":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}},"k":{"docs":{},"e":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.009626955475330927}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"是":{"docs":{},"s":{"docs":{},"n":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},"遵":{"docs":{},"循":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},"r":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0087527352297593}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"新":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"插":{"docs":{},"入":{"docs":{},"列":{"docs":{},"表":{"docs":{},"的":{"docs":{},"最":{"docs":{},"开":{"docs":{},"始":{"docs":{},"位":{"docs":{},"置":{"docs":{},"，":{"docs":{},"并":{"docs":{},"且":{"docs":{},"使":{"docs":{},"用":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"）":{"docs":{},"根":{"docs":{},"据":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"推":{"docs":{},"断":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}}},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6666666666666665}}}}}}}}}}}}}}},")":{"docs":{},"和":{"docs":{},"显":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}},"r":{"docs":{},"c":{"docs":{},"=":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},"s":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"d":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"/":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"/":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"/":{"docs":{},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"/":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"/":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"/":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"_":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"/":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"_":{"docs":{},"q":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}},"docs":{}}}},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}},"docs":{}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},"v":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.033391915641476276},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.06870229007633588},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"i":{"docs":{},"m":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"y":{"docs":{},"y":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.007619047619047619},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"s":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}},"例":{"docs":{},"子":{"docs":{},"是":{"docs":{},"基":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"数":{"docs":{},"学":{"docs":{},"公":{"docs":{},"式":{"docs":{},"。":{"docs":{},"它":{"docs":{},"并":{"docs":{},"不":{"docs":{},"适":{"docs":{},"合":{"docs":{},"开":{"docs":{},"放":{"docs":{},"写":{"docs":{},"权":{"docs":{},"限":{"docs":{},"来":{"docs":{},"对":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"只":{"docs":{},"读":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"用":{"docs":{},"法":{"docs":{},"，":{"docs":{},"该":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"用":{"docs":{},"来":{"docs":{},"展":{"docs":{},"示":{"docs":{},"传":{"docs":{},"入":{"docs":{},"整":{"docs":{},"数":{"docs":{},"的":{"docs":{},"n":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"三":{"docs":{},"倍":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"数":{"docs":{},"值":{"3":{"docs":{},"作":{"docs":{},"为":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"入":{"docs":{},"参":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"实":{"docs":{},"例":{"docs":{},"成":{"docs":{},"员":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}},"d":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}},"和":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"失":{"docs":{},"败":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"它":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"）":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"被":{"docs":{},"写":{"docs":{},"作":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"?":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"问":{"docs":{},"号":{"docs":{},"暗":{"docs":{},"示":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"可":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"也":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"值":{"docs":{},"。":{"docs":{},"（":{"docs":{},"不":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"其":{"docs":{},"他":{"docs":{},"任":{"docs":{},"何":{"docs":{},"值":{"docs":{},"比":{"docs":{},"如":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"值":{"docs":{},"或":{"docs":{},"者":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"。":{"docs":{},"只":{"docs":{},"能":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"将":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"i":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}},"k":{"docs":{},"y":{"docs":{},"o":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.015555555555555555}},"s":{"docs":{},"设":{"docs":{},"置":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"函":{"docs":{},"数":{"docs":{},"。":{"docs":{},"根":{"docs":{},"据":{"docs":{},"函":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"推":{"docs":{},"测":{"docs":{},"，":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"可":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"切":{"docs":{},"换":{"docs":{},"或":{"docs":{},"恢":{"docs":{},"复":{"docs":{},"某":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"状":{"docs":{},"态":{"docs":{},"。":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"在":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"前":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"s":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}}}}}}}},"那":{"docs":{},"些":{"docs":{},"包":{"docs":{},"含":{"docs":{},"可":{"docs":{},"选":{"docs":{},"成":{"docs":{},"员":{"docs":{},"需":{"docs":{},"求":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"以":{"docs":{},"及":{"docs":{},"如":{"docs":{},"何":{"docs":{},"访":{"docs":{},"问":{"docs":{},"可":{"docs":{},"选":{"docs":{},"协":{"docs":{},"议":{"docs":{},"成":{"docs":{},"员":{"docs":{},"的":{"docs":{},"指":{"docs":{},"导":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"当":{"docs":{},"你":{"docs":{},"不":{"docs":{},"确":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"-":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}}}}}}}},".":{"0":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"1":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}},"k":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.018315018315018316}},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}},"类":{"docs":{},"也":{"docs":{},"继":{"docs":{},"承":{"docs":{},"了":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}},"b":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"（":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"z":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}},"）":{"docs":{},"\\":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"9":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}},"docs":{},"b":{"docs":{},"）":{"docs":{},"、":{"docs":{},"换":{"docs":{},"页":{"docs":{},"符":{"docs":{},"（":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"k":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"m":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}}}}}}}},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.015503875968992248}}},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"你":{"docs":{},"依":{"docs":{},"然":{"docs":{},"可":{"docs":{},"以":{"docs":{},"改":{"docs":{},"变":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"本":{"docs":{},"身":{"docs":{},"不":{"docs":{},"会":{"docs":{},"改":{"docs":{},"变":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"并":{"docs":{},"不":{"docs":{},"储":{"docs":{},"存":{"docs":{},"这":{"docs":{},"个":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"在":{"docs":{},"后":{"docs":{},"台":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"对":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"，":{"docs":{},"改":{"docs":{},"变":{"docs":{},"的":{"docs":{},"是":{"docs":{},"被":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"会":{"docs":{},"发":{"docs":{},"现":{"docs":{},"它":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"显":{"docs":{},"示":{"docs":{},"了":{"docs":{},"基":{"docs":{},"本":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"新":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"，":{"docs":{},"其":{"docs":{},"值":{"docs":{},"为":{"3":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"其":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"新":{"docs":{},"实":{"docs":{},"例":{"docs":{},"。":{"docs":{},"在":{"docs":{},"之":{"docs":{},"前":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"中":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"视":{"docs":{},"频":{"docs":{},"模":{"docs":{},"式":{"docs":{},"(":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786}}}}}}}},"r":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.009191176470588236}},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.009523809523809525}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.014059753954305799}}},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"s":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.01904761904761905}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"/":{"docs":{},"p":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"或":{"docs":{},"者":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"还":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"p":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"值":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"该":{"docs":{},"标":{"docs":{},"签":{"docs":{},"就":{"docs":{},"包":{"docs":{},"含":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"，":{"docs":{},"该":{"docs":{},"标":{"docs":{},"签":{"docs":{},"就":{"docs":{},"不":{"docs":{},"包":{"docs":{},"含":{"docs":{},"文":{"docs":{},"本":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"段":{"docs":{},"落":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"根":{"docs":{},"据":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"是":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475}}}}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"被":{"docs":{},"用":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"6":{"docs":{},"]":{"docs":{},"。":{"docs":{},"这":{"docs":{},"句":{"docs":{},"话":{"docs":{},"访":{"docs":{},"问":{"docs":{},"了":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"第":{"docs":{},"六":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"1":{"8":{"docs":{},"或":{"docs":{},"者":{"6":{"docs":{},"的":{"3":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"作":{"docs":{},"为":{"docs":{},"数":{"docs":{},"据":{"docs":{},"源":{"docs":{},"开":{"docs":{},"实":{"docs":{},"例":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.005479452054794521},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},")":{"docs":{},"控":{"docs":{},"制":{"docs":{},"传":{"docs":{},"递":{"docs":{},"语":{"docs":{},"句":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.1111111111111112}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"g":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.013363028953229399},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976}},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}},".":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}},"docs":{}}},"3":{"docs":{},".":{"1":{"4":{"1":{"5":{"9":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"4":{"2":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}},"docs":{}},"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}},"(":{"3":{"docs":{},".":{"0":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}},"docs":{}}},"docs":{}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"的":{"docs":{},"每":{"docs":{},"一":{"docs":{},"项":{"docs":{},"的":{"docs":{},"并":{"docs":{},"用":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"查":{"docs":{},"找":{"docs":{},"每":{"docs":{},"一":{"docs":{},"项":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"几":{"docs":{},"种":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"直":{"docs":{},"接":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"，":{"docs":{},"并":{"docs":{},"调":{"docs":{},"用":{"docs":{},"其":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"当":{"docs":{},"做":{"docs":{},"是":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"h":{"docs":{},"a":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"等":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"能":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}},"u":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.02195121951219512},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}},"。":{"docs":{},"从":{"docs":{},"字":{"docs":{},"面":{"docs":{},"意":{"docs":{},"思":{"docs":{},"来":{"docs":{},"说":{"docs":{},"，":{"docs":{},"断":{"docs":{},"言":{"docs":{},"“":{"docs":{},"断":{"docs":{},"言":{"docs":{},"”":{"docs":{},"一":{"docs":{},"个":{"docs":{},"条":{"docs":{},"件":{"docs":{},"是":{"docs":{},"否":{"docs":{},"为":{"docs":{},"真":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"断":{"docs":{},"言":{"docs":{},"来":{"docs":{},"保":{"docs":{},"证":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"其":{"docs":{},"他":{"docs":{},"代":{"docs":{},"码":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"某":{"docs":{},"些":{"docs":{},"重":{"docs":{},"要":{"docs":{},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"满":{"docs":{},"足":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"代":{"docs":{},"码":{"docs":{},"运":{"docs":{},"行":{"docs":{},"会":{"docs":{},"继":{"docs":{},"续":{"docs":{},"进":{"docs":{},"行":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"，":{"docs":{},"则":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"部":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}},"即":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"示":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"黑":{"docs":{},"格":{"docs":{},"，":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"将":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"转":{"docs":{},"到":{"docs":{},"第":{"3":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"都":{"docs":{},"不":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"转":{"docs":{},"到":{"docs":{},"第":{"1":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"步":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"为":{"docs":{},"假":{"docs":{},"(":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.014652014652014652}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.910995670995671}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":10.00321199143469}}}}},"e":{"docs":{},"r":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}},"i":{"docs":{},"l":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"）":{"docs":{},"的":{"docs":{},"叶":{"docs":{},"子":{"docs":{},"节":{"docs":{},"点":{"docs":{},"传":{"docs":{},"向":{"docs":{},"根":{"docs":{},"节":{"docs":{},"点":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"d":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"l":{"docs":{},"i":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"p":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.005928853754940711},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}},"e":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}},"y":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}},"e":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"-":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"i":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}}}}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"然":{"docs":{},"而":{"docs":{},"常":{"docs":{},"量":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"不":{"docs":{},"能":{"docs":{},"直":{"docs":{},"接":{"docs":{},"相":{"docs":{},"加":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"同":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"要":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"数":{"docs":{},"字":{"docs":{},"并":{"docs":{},"用":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.008849557522123894},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":5.006564551422319},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.47481324876673714},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":1.1200663349917082},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.44498669032830523},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":5.006681514476615},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6695402298850572},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":10.075208913649025},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.37644813956658035},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.03640256959314775},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.014383561643835616}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.008787346221441126},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"s":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"s":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"使":{"docs":{},"用":{"docs":{},"字":{"docs":{},"符":{"docs":{},"（":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2857142857142857}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"作":{"docs":{},"为":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}}}},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}},"—":{"docs":{},"—":{"docs":{},"比":{"docs":{},"如":{"docs":{},"表":{"docs":{},"示":{"docs":{},"数":{"docs":{},"字":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"和":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"—":{"docs":{},"—":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"就":{"docs":{},"是":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"知":{"docs":{},"道":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"有":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"构":{"docs":{},"造":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"去":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"新":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"如":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"、":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"外":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"、":{"docs":{},"元":{"docs":{},"组":{"docs":{},"、":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"类":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"和":{"docs":{},"可":{"docs":{},"选":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"甚":{"docs":{},"至":{"docs":{},"是":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"值":{"docs":{},"和":{"docs":{},"指":{"docs":{},"定":{"docs":{},"的":{"docs":{},"范":{"docs":{},"围":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},")":{"docs":{},"等":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"些":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"控":{"docs":{},"制":{"docs":{},"流":{"docs":{},"一":{"docs":{},"章":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00821917808219178}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.013927576601671309},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.010273972602739725}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}},"=":{"docs":{},"=":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"e":{"docs":{},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}},"。":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"自":{"docs":{},"动":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"空":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}},"协":{"docs":{},"议":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"—":{"docs":{},"—":{"docs":{},"并":{"docs":{},"不":{"docs":{},"是":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"适":{"docs":{},"配":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"具":{"docs":{},"体":{"docs":{},"类":{"docs":{},"型":{"docs":{},"—":{"docs":{},"—":{"docs":{},"是":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"名":{"docs":{},"字":{"docs":{},"紧":{"docs":{},"跟":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"类":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"的":{"docs":{},"元":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"属":{"docs":{},"性":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"在":{"docs":{},"前":{"docs":{},"面":{"docs":{},"加":{"docs":{},"上":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"是":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"本":{"docs":{},"是":{"docs":{},"没":{"docs":{},"有":{"docs":{},"定":{"docs":{},"义":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"，":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"能":{"docs":{},"成":{"docs":{},"功":{"docs":{},"调":{"docs":{},"用":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"如":{"docs":{},"果":{"docs":{},"方":{"docs":{},"法":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"的":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"将":{"docs":{},"会":{"docs":{},"是":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"）":{"docs":{},"中":{"docs":{},"，":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"成":{"docs":{},"员":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"是":{"docs":{},"访":{"docs":{},"问":{"docs":{},"某":{"docs":{},"个":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"常":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"项":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"在":{"docs":{},"类":{"docs":{},"型":{"docs":{},"接":{"docs":{},"口":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"(":{"docs":{},"译":{"docs":{},"者":{"docs":{},"注":{"docs":{},"：":{"docs":{},"特":{"docs":{},"指":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},")":{"docs":{},"中":{"docs":{},"的":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"加":{"docs":{},"上":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"修":{"docs":{},"改":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"相":{"docs":{},"当":{"docs":{},"于":{"docs":{},"修":{"docs":{},"改":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"而":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"默":{"docs":{},"认":{"docs":{},"不":{"docs":{},"允":{"docs":{},"许":{"docs":{},"修":{"docs":{},"改":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"需":{"docs":{},"要":{"docs":{},"前":{"docs":{},"置":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"方":{"docs":{},"便":{"docs":{},"的":{"docs":{},"修":{"docs":{},"改":{"docs":{},"实":{"docs":{},"例":{"docs":{},"及":{"docs":{},"其":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"值":{"docs":{},"而":{"docs":{},"无":{"docs":{},"需":{"docs":{},"改":{"docs":{},"变":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"而":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"均":{"docs":{},"为":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"与":{"docs":{},"先":{"docs":{},"前":{"docs":{},"的":{"docs":{},"不":{"docs":{},"同":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"此":{"docs":{},"时":{"docs":{},"，":{"docs":{},"必":{"docs":{},"须":{"docs":{},"使":{"docs":{},"用":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"在":{"docs":{},"声":{"docs":{},"明":{"docs":{},"时":{"docs":{},"候":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"（":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"（":{"docs":{},"当":{"docs":{},"然":{"docs":{},"了":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"我":{"docs":{},"都":{"docs":{},"知":{"docs":{},"道":{"docs":{},"它":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"了":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"动":{"docs":{},"态":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"吗":{"docs":{},"）":{"docs":{},"。":{"docs":{},"动":{"docs":{},"态":{"docs":{},"类":{"docs":{},"型":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"某":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"o":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}}}},"-":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}}}}},"分":{"docs":{},"别":{"docs":{},"代":{"docs":{},"表":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}},"和":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"u":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"要":{"docs":{},"求":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"等":{"docs":{},"同":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"这":{"docs":{},"样":{"docs":{},"来":{"docs":{},"表":{"docs":{},"达":{"docs":{},"：":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"“":{"docs":{},"某":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"”":{"docs":{},"的":{"docs":{},"节":{"docs":{},"点":{"docs":{},"提":{"docs":{},"供":{"docs":{},"给":{"docs":{},"后":{"docs":{},"来":{"docs":{},"用":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"将":{"docs":{},"来":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"里":{"docs":{},"任":{"docs":{},"何":{"docs":{},"地":{"docs":{},"方":{"docs":{},"表":{"docs":{},"示":{"docs":{},"为":{"docs":{},"“":{"docs":{},"t":{"docs":{},"”":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"所":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"t":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"占":{"docs":{},"位":{"docs":{},"命":{"docs":{},"名":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"）":{"docs":{},"来":{"docs":{},"代":{"docs":{},"替":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"（":{"docs":{},"如":{"docs":{},"i":{"docs":{},"n":{"docs":{},"、":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"或":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"）":{"docs":{},"。":{"docs":{},"占":{"docs":{},"位":{"docs":{},"类":{"docs":{},"型":{"docs":{},"名":{"docs":{},"没":{"docs":{},"有":{"docs":{},"提":{"docs":{},"示":{"docs":{},"t":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"什":{"docs":{},"么":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"它":{"docs":{},"提":{"docs":{},"示":{"docs":{},"了":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"型":{"docs":{},"t":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"管":{"docs":{},"t":{"docs":{},"表":{"docs":{},"示":{"docs":{},"什":{"docs":{},"么":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"只":{"docs":{},"有":{"docs":{},"s":{"docs":{},"w":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"函":{"docs":{},"数":{"docs":{},"在":{"docs":{},"每":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"所":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"类":{"docs":{},"型":{"docs":{},"才":{"docs":{},"能":{"docs":{},"决":{"docs":{},"定":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"下":{"docs":{},"标":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"是":{"docs":{},"用":{"docs":{},"尖":{"docs":{},"括":{"docs":{},"号":{"docs":{},"括":{"docs":{},"起":{"docs":{},"来":{"docs":{},"的":{"docs":{},"（":{"docs":{},"<":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}},"，":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"t":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"子":{"docs":{},"类":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"约":{"docs":{},"束":{"docs":{},"；":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"u":{"docs":{},"，":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"需":{"docs":{},"要":{"docs":{},"u":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"@":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368}}}}}}}}}}}},"u":{"docs":{},"，":{"docs":{},"v":{"docs":{},"，":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}},"则":{"docs":{},"是":{"docs":{},"跟":{"docs":{},"这":{"docs":{},"些":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"的":{"docs":{},"公":{"docs":{},"共":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}},"u":{"0":{"0":{"0":{"1":{"docs":{},"f":{"4":{"9":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"2":{"6":{"6":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter1/chapter1.html#gitbook_6470":{"ref":"chapter1/chapter1.html#gitbook_6470","tf":0.25},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter2/chapter2.html#gitbook_6516":{"ref":"chapter2/chapter2.html#gitbook_6516","tf":0.3333333333333333},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":1.2116303770578862},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"是":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"2":{"1":{"docs":{},"位":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"3":{"2":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},"是":{"2":{"1":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"）":{"docs":{},"和":{"docs":{},"变":{"docs":{},"体":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"体":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}},"标":{"docs":{},"签":{"docs":{},"联":{"docs":{},"合":{"docs":{},"（":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.010619469026548672},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}},"u":{"docs":{},"s":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"确":{"docs":{},"定":{"docs":{},"数":{"docs":{},"组":{"docs":{},"引":{"docs":{},"用":{"docs":{},"的":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"性":{"docs":{},"。":{"docs":{},"(":{"docs":{},"当":{"docs":{},"数":{"docs":{},"组":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"常":{"docs":{},"量":{"docs":{},"时":{"docs":{},"，":{"docs":{},"不":{"docs":{},"能":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"调":{"docs":{},"用":{"docs":{},"后":{"docs":{},"再":{"docs":{},"修":{"docs":{},"改":{"docs":{},"b":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"这":{"docs":{},"三":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},",":{"docs":{},"b":{"docs":{},",":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"方":{"docs":{},"法":{"docs":{},"仅":{"docs":{},"会":{"docs":{},"在":{"docs":{},"确":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"时":{"docs":{},"才":{"docs":{},"会":{"docs":{},"创":{"docs":{},"建":{"docs":{},"数":{"docs":{},"组":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796}},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"等":{"docs":{},"级":{"6":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"未":{"docs":{},"购":{"docs":{},"买":{"docs":{},"状":{"docs":{},"态":{"docs":{},"开":{"docs":{},"始":{"docs":{},"的":{"docs":{},"。":{"docs":{},"为":{"docs":{},"了":{"docs":{},"展":{"docs":{},"现":{"docs":{},"这":{"docs":{},"一":{"docs":{},"事":{"docs":{},"实":{"docs":{},"，":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"引":{"docs":{},"入":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"p":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"是":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"还":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"它":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"关":{"docs":{},"于":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.009523809523809525},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"e":{"docs":{},"d":{"docs":{},"（":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"(":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}}}},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}},"p":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},":":{"docs":{},")":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"。":{"docs":{},"举":{"docs":{},"例":{"docs":{},"来":{"docs":{},"说":{"docs":{},"：":{"docs":{},"对":{"docs":{},"于":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"值":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"设":{"docs":{},"置":{"docs":{},"或":{"docs":{},"者":{"docs":{},"更":{"docs":{},"新":{"docs":{},"特":{"docs":{},"定":{"docs":{},"键":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"就":{"docs":{},"像":{"docs":{},"上":{"docs":{},"面":{"docs":{},"所":{"docs":{},"示":{"docs":{},"的":{"docs":{},"示":{"docs":{},"例":{"docs":{},"，":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}},"a":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}},"(":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"现":{"docs":{},"有":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"。":{"docs":{},"注":{"docs":{},"意":{"docs":{},"，":{"docs":{},"你":{"docs":{},"并":{"docs":{},"不":{"docs":{},"能":{"docs":{},"传":{"docs":{},"入":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"只":{"docs":{},"能":{"docs":{},"传":{"docs":{},"入":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"进":{"docs":{},"行":{"docs":{},"相":{"docs":{},"加":{"docs":{},"。":{"docs":{},"目":{"docs":{},"标":{"docs":{},"常":{"docs":{},"量":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"推":{"docs":{},"测":{"docs":{},"为":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"是":{"docs":{},"两":{"docs":{},"个":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"3":{"2":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}},"的":{"docs":{},"命":{"docs":{},"名":{"docs":{},"为":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"k":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"来":{"docs":{},"存":{"docs":{},"储":{"docs":{},"层":{"docs":{},"叠":{"docs":{},"样":{"docs":{},"式":{"docs":{},"表":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"中":{"docs":{},"粉":{"docs":{},"色":{"docs":{},"的":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"，":{"docs":{},"c":{"docs":{},"s":{"docs":{},"s":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"#":{"docs":{},"c":{"docs":{},"c":{"6":{"6":{"9":{"9":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"用":{"docs":{},"十":{"docs":{},"六":{"docs":{},"进":{"docs":{},"制":{"0":{"docs":{},"x":{"docs":{},"c":{"docs":{},"c":{"6":{"6":{"9":{"9":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"使":{"docs":{},"用":{"docs":{},"按":{"docs":{},"位":{"docs":{},"与":{"docs":{},"(":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},")":{"docs":{},"和":{"docs":{},"按":{"docs":{},"位":{"docs":{},"右":{"docs":{},"移":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"这":{"docs":{},"个":{"docs":{},"颜":{"docs":{},"色":{"docs":{},"值":{"docs":{},"中":{"docs":{},"解":{"docs":{},"析":{"docs":{},"出":{"docs":{},"红":{"docs":{},"(":{"docs":{},"c":{"docs":{},"c":{"docs":{},")":{"docs":{},"，":{"docs":{},"绿":{"docs":{},"(":{"6":{"6":{"docs":{},")":{"docs":{},"，":{"docs":{},"蓝":{"docs":{},"(":{"9":{"9":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"8":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.008849557522123894},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.016697588126159554}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}},"是":{"8":{"docs":{},"位":{"docs":{},"无":{"docs":{},"符":{"docs":{},"整":{"docs":{},"型":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"0":{"docs":{},"~":{"2":{"5":{"5":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"任":{"docs":{},"意":{"docs":{},"数":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"为":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"值":{"0":{"0":{"0":{"0":{"1":{"1":{"1":{"1":{"docs":{},"(":{"docs":{},"前":{"4":{"docs":{},"位":{"docs":{},"为":{"0":{"docs":{},"，":{"docs":{},"后":{"4":{"docs":{},"位":{"docs":{},"为":{"1":{"docs":{},")":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"值":{"docs":{},"为":{"1":{"5":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}}},"docs":{}}}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}},"docs":{}},"的":{"docs":{},"最":{"docs":{},"小":{"docs":{},"值":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{},"是":{"0":{"docs":{},"(":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"为":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},"。":{"docs":{},"使":{"docs":{},"用":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"-":{"docs":{},"进":{"docs":{},"行":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"减":{"1":{"docs":{},"，":{"docs":{},"就":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"docs":{},"即":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"的":{"2":{"5":{"5":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"docs":{}}}}}}},"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},"，":{"docs":{},"除":{"docs":{},"非":{"docs":{},"你":{"docs":{},"真":{"docs":{},"的":{"docs":{},"需":{"docs":{},"要":{"docs":{},"存":{"docs":{},"储":{"docs":{},"一":{"docs":{},"个":{"docs":{},"和":{"docs":{},"当":{"docs":{},"前":{"docs":{},"平":{"docs":{},"台":{"docs":{},"原":{"docs":{},"生":{"docs":{},"字":{"docs":{},"长":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"无":{"docs":{},"符":{"docs":{},"号":{"docs":{},"整":{"docs":{},"数":{"docs":{},"。":{"docs":{},"除":{"docs":{},"了":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"最":{"docs":{},"好":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"你":{"docs":{},"要":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"值":{"docs":{},"已":{"docs":{},"知":{"docs":{},"是":{"docs":{},"非":{"docs":{},"负":{"docs":{},"的":{"docs":{},"。":{"docs":{},"统":{"docs":{},"一":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"使":{"docs":{},"用":{"docs":{},"来":{"docs":{},"模":{"docs":{},"拟":{"docs":{},"试":{"docs":{},"图":{"docs":{},"控":{"docs":{},"制":{"docs":{},"器":{"docs":{},"的":{"docs":{},"导":{"docs":{},"航":{"docs":{},"结":{"docs":{},"构":{"docs":{},"。":{"docs":{},"你":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"v":{"docs":{},"i":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"为":{"docs":{},"导":{"docs":{},"航":{"docs":{},"栈":{"docs":{},"添":{"docs":{},"加":{"docs":{},"（":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"）":{"docs":{},"新":{"docs":{},"的":{"docs":{},"试":{"docs":{},"图":{"docs":{},"控":{"docs":{},"制":{"docs":{},"器":{"docs":{},"；":{"docs":{},"而":{"docs":{},"通":{"docs":{},"过":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"从":{"docs":{},"导":{"docs":{},"航":{"docs":{},"栈":{"docs":{},"中":{"docs":{},"移":{"docs":{},"除":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"+":{"0":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"a":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"2":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{},"a":{"8":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"b":{"2":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"5":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}}},"docs":{}},"docs":{}}}}},"7":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{},"c":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}}}}}},"c":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"d":{"6":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}}},"docs":{}},"docs":{}}}}},"docs":{}},"d":{"8":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"f":{"6":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}}},"docs":{}},"docs":{}}}}},"docs":{}},"f":{"8":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"3":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"0":{"3":{"6":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"7":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"6":{"7":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"1":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"8":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"8":{"0":{"docs":{},"f":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"d":{"docs":{},"b":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"docs":{}}}}}},"docs":{}},"docs":{},"f":{"4":{"3":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}},"docs":{}},"9":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}},"docs":{}},"d":{"docs":{},"c":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"docs":{}}}}},"docs":{}}},"e":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"docs":{}}}}},"docs":{}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{},"b":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"2":{"docs":{},"a":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"2":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"docs":{}},"docs":{}}}}}},"3":{"docs":{},"f":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"4":{"0":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"5":{"4":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"6":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"6":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"7":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"docs":{},"c":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{},"d":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"0":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{}}},"1":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"1":{"8":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"4":{"6":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"4":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"6":{"6":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}},"7":{"7":{"6":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"7":{"9":{"3":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{},"c":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"e":{"8":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"2":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}},"docs":{}}}}},"docs":{}},"docs":{}}},"3":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"4":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"0":{"7":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"2":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"2":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"3":{"1":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"3":{"0":{"3":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}},"docs":{}},"docs":{}}}}},"docs":{}},"4":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"d":{"7":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"4":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"4":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"5":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"6":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"7":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"8":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"9":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"docs":{}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"d":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"d":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}},"docs":{}},"docs":{}},"a":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"a":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"b":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"b":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"c":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"c":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"0":{"0":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"f":{"9":{"0":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"d":{"3":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}}}}}}},"docs":{}},"docs":{}},"docs":{},"d":{"4":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"d":{"docs":{},"c":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}},"docs":{}},"docs":{},"f":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"1":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}}}}}}},"docs":{}}},"e":{"2":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"2":{"docs":{},"f":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}},"docs":{}}}}}}},"docs":{}},"3":{"0":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"e":{"4":{"4":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}},"docs":{}},"docs":{}}}}}}},"docs":{}},"4":{"7":{"docs":{},"–":{"docs":{},"u":{"docs":{},"+":{"docs":{},"f":{"docs":{},"f":{"docs":{},"f":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}},"docs":{}},"docs":{}}}},"s":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}},"t":{"docs":{},"f":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"1":{"6":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"是":{"docs":{},"无":{"docs":{},"符":{"docs":{},"号":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"8":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{},"是":{"docs":{},"无":{"docs":{},"符":{"docs":{},"号":{"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"访":{"docs":{},"问":{"docs":{},"它":{"docs":{},"的":{"docs":{},"u":{"docs":{},"t":{"docs":{},"f":{"docs":{},"-":{"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}}}}}}}}}}}}},"docs":{},"-":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777}},"（":{"docs":{},"以":{"1":{"6":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}}}},"docs":{}},"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.011152416356877323}},"（":{"docs":{},"以":{"8":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}}}},"docs":{}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}},"v":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"c":{"docs":{},"l":{"docs":{},"w":{"docs":{},"e":{"docs":{},"i":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}},"i":{"docs":{},"z":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}}}}},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}},"e":{"docs":{},"中":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"视":{"docs":{},"频":{"docs":{},"显":{"docs":{},"示":{"docs":{},"器":{"docs":{},"的":{"docs":{},"特":{"docs":{},"定":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"类":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"四":{"docs":{},"个":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"，":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"具":{"docs":{},"有":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"新":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"同":{"docs":{},"时":{"docs":{},"还":{"docs":{},"会":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"其":{"docs":{},"它":{"docs":{},"三":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"分":{"docs":{},"别":{"docs":{},"是":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"意":{"docs":{},"为":{"docs":{},"“":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"”":{"docs":{},")":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"，":{"docs":{},"回":{"docs":{},"放":{"docs":{},"帧":{"docs":{},"率":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"为":{"0":{"docs":{},".":{"0":{"docs":{},"的":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"和":{"docs":{},"值":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"。":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"会":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"意":{"docs":{},"为":{"docs":{},"“":{"docs":{},"没":{"docs":{},"有":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.012389380530973451},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2894317578332448},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0262582056892779},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.01619047619047619},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":3.3699999999999997},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.4398846495119787},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0200445434298441},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.047244094488188976},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.015817223198594025},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.014822134387351778},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.01284796573875803},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"定":{"docs":{},"义":{"docs":{},",":{"docs":{},"其":{"docs":{},"中":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"是":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"键":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.012302284710017574}}}}}}}},"）":{"docs":{},"都":{"docs":{},"关":{"docs":{},"联":{"docs":{},"独":{"docs":{},"特":{"docs":{},"的":{"docs":{},"键":{"docs":{},"（":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"些":{"docs":{},"量":{"docs":{},"是":{"docs":{},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"修":{"docs":{},"改":{"docs":{},"的":{"docs":{},"。":{"docs":{},"当":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"作":{"docs":{},"为":{"docs":{},"输":{"docs":{},"入":{"docs":{},"输":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"前":{"docs":{},"加":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"键":{"docs":{},"（":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"）":{"docs":{},"解":{"docs":{},"读":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"，":{"docs":{},"字":{"docs":{},"典":{"docs":{},"的":{"docs":{},"值":{"docs":{},"会":{"docs":{},"被":{"docs":{},"解":{"docs":{},"读":{"docs":{},"为":{"docs":{},"常":{"docs":{},"量":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"循":{"docs":{},"环":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"名":{"docs":{},"称":{"docs":{},"来":{"docs":{},"解":{"docs":{},"读":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"检":{"docs":{},"查":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"所":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"来":{"docs":{},"证":{"docs":{},"明":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"确":{"docs":{},"实":{"docs":{},"是":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"了":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"在":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"将":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"值":{"docs":{},"设":{"docs":{},"为":{"2":{"4":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"修":{"docs":{},"改":{"docs":{},"前":{"docs":{},"的":{"docs":{},"值":{"2":{"3":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"其":{"docs":{},"不":{"docs":{},"可":{"docs":{},"访":{"docs":{},"问":{"docs":{},"时":{"docs":{},"，":{"docs":{},"?":{"docs":{},"之":{"docs":{},"后":{"docs":{},"语":{"docs":{},"句":{"docs":{},"不":{"docs":{},"会":{"docs":{},"执":{"docs":{},"行":{"docs":{},"，":{"docs":{},"并":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"）":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"称":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}},"可":{"docs":{},"变":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}},"多":{"docs":{},"重":{"docs":{},"输":{"docs":{},"入":{"docs":{},"参":{"docs":{},"数":{"docs":{},"（":{"docs":{},"m":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"函":{"docs":{},"数":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"外":{"docs":{},"部":{"docs":{},"参":{"docs":{},"数":{"docs":{},"名":{"docs":{},"（":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23255813953488372}}}}}}}}}}}}}}}}}}}},"闭":{"docs":{},"包":{"docs":{},"是":{"docs":{},"引":{"docs":{},"用":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5555555555555556}}}}}}}}}}}}}}}},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"（":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":3.333333333333333}}}}}}}}}},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.023622047244094488}}}}}}}}},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"-":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.048},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02564102564102564},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.01415929203539823},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.01486988847583643},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.02188183807439825},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.017142857142857144},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01090909090909091},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.011940298507462687},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.03875968992248062},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.06},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.02806122448979592},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.016216216216216217},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.04411764705882353},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.01935483870967742},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0380952380952381},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.028662420382165606},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.023622047244094488},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.034482758620689655},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.039711191335740074},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.028119507908611598},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.014842300556586271},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.019498607242339833},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.009881422924901186},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.008565310492505354},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.23377026074700494},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.004794520547945206},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.004794520547945206}},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}}}}}}}}},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}},"或":{"docs":{},"者":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"定":{"docs":{},"义":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"包":{"docs":{},"括":{"docs":{},"只":{"docs":{},"读":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"。":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"）":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"存":{"docs":{},"储":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"用":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762}}},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}},"y":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198}},"e":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"，":{"docs":{},"叫":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"，":{"docs":{},"它":{"docs":{},"重":{"docs":{},"写":{"docs":{},"了":{"docs":{},"从":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"类":{"docs":{},"继":{"docs":{},"承":{"docs":{},"来":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"基":{"docs":{},"类":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"基":{"docs":{},"类":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"对":{"docs":{},"所":{"docs":{},"有":{"docs":{},"车":{"docs":{},"辆":{"docs":{},"都":{"docs":{},"通":{"docs":{},"用":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"和":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"属":{"docs":{},"性":{"docs":{},"在":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"方":{"docs":{},"法":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"对":{"docs":{},"自":{"docs":{},"行":{"docs":{},"车":{"docs":{},"来":{"docs":{},"说":{"docs":{},"已":{"docs":{},"经":{"docs":{},"是":{"docs":{},"正":{"docs":{},"确":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"在":{"docs":{},"b":{"docs":{},"i":{"docs":{},"c":{"docs":{},"y":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"改":{"docs":{},"变":{"docs":{},"它":{"docs":{},"。":{"docs":{},"而":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"（":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}},"的":{"docs":{},"基":{"docs":{},"础":{"docs":{},"上":{"docs":{},"创":{"docs":{},"建":{"docs":{},"起":{"docs":{},"来":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"v":{"docs":{},"e":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"为":{"docs":{},"任":{"docs":{},"意":{"docs":{},"的":{"docs":{},"一":{"docs":{},"辆":{"docs":{},"车":{"docs":{},"设":{"docs":{},"置":{"docs":{},"一":{"docs":{},"些":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"（":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}},"s":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.04638218923933209}},"(":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.027829313543599257}}}},"对":{"docs":{},"象":{"docs":{},"是":{"docs":{},"否":{"docs":{},"有":{"docs":{},"相":{"docs":{},"等":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"相":{"docs":{},"等":{"docs":{},"的":{"docs":{},"概":{"docs":{},"念":{"docs":{},"就":{"docs":{},"是":{"docs":{},"他":{"docs":{},"们":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"x":{"docs":{},"值":{"docs":{},"和":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"单":{"docs":{},"目":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"-":{"docs":{},"a":{"docs":{},"，":{"docs":{},"@":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"也":{"docs":{},"是":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"需":{"docs":{},"要":{"docs":{},"定":{"docs":{},"义":{"docs":{},"和":{"docs":{},"实":{"docs":{},"现":{"docs":{},"一":{"docs":{},"个":{"docs":{},"中":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"在":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"任":{"docs":{},"意":{"docs":{},"两":{"docs":{},"个":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"2":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}},"docs":{}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"单":{"docs":{},"目":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"将":{"docs":{},"其":{"docs":{},"x":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}},"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.01855287569573284}},".":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}},"t":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.007272727272727273},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.014367816091954023}},"代":{"docs":{},"替":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},".":{"docs":{},"v":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}},"。":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"中":{"docs":{},"，":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}},"它":{"docs":{},"其":{"docs":{},"实":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"（":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}},"?":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"当":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"调":{"docs":{},"用":{"docs":{},"方":{"docs":{},"法":{"docs":{},"时":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"总":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"参":{"docs":{},"见":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}},"是":{"docs":{},"空":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},")":{"docs":{},"的":{"docs":{},"别":{"docs":{},"名":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"就":{"docs":{},"是":{"docs":{},"括":{"docs":{},"号":{"docs":{},"内":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667}}}}}},"g":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}},"w":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"h":{"1":{"1":{"0":{"0":{"7":{"1":{"7":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"，":{"docs":{},"只":{"docs":{},"在":{"docs":{},"冒":{"docs":{},"号":{"docs":{},"后":{"docs":{},"面":{"docs":{},"写":{"docs":{},"接":{"docs":{},"口":{"docs":{},"或":{"docs":{},"者":{"docs":{},"类":{"docs":{},"名":{"docs":{},"。":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"队":{"docs":{},"列":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"使":{"docs":{},"你":{"docs":{},"能":{"docs":{},"够":{"docs":{},"要":{"docs":{},"求":{"docs":{},"一":{"docs":{},"个":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"（":{"docs":{},"或":{"docs":{},"）":{"docs":{},"那":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"参":{"docs":{},"数":{"docs":{},"和":{"docs":{},"关":{"docs":{},"联":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"紧":{"docs":{},"随":{"docs":{},"放":{"docs":{},"置":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"写":{"docs":{},"在":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}},"。":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"由":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"要":{"docs":{},"求":{"docs":{},"用":{"docs":{},"于":{"docs":{},"指":{"docs":{},"明":{"docs":{},"该":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"某":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"遵":{"docs":{},"守":{"docs":{},"某":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"。":{"docs":{},"尽":{"docs":{},"管":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"有":{"docs":{},"助":{"docs":{},"于":{"docs":{},"表":{"docs":{},"达":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"上":{"docs":{},"的":{"docs":{},"简":{"docs":{},"单":{"docs":{},"约":{"docs":{},"束":{"docs":{},"（":{"docs":{},"如":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"­":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198}}}}},"i":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"条":{"docs":{},"件":{"docs":{},"语":{"docs":{},"句":{"docs":{},"i":{"docs":{},"f":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"不":{"docs":{},"存":{"docs":{},"在":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"贯":{"docs":{},"穿":{"docs":{},"（":{"docs":{},"n":{"docs":{},"o":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9090909090909092}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"循":{"docs":{},"环":{"docs":{},"从":{"docs":{},"计":{"docs":{},"算":{"docs":{},"单":{"docs":{},"一":{"docs":{},"条":{"docs":{},"件":{"docs":{},"开":{"docs":{},"始":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"会":{"docs":{},"重":{"docs":{},"复":{"docs":{},"运":{"docs":{},"行":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"直":{"docs":{},"到":{"docs":{},"条":{"docs":{},"件":{"docs":{},"变":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"体":{"docs":{},"中":{"docs":{},"调":{"docs":{},"用":{"docs":{},"b":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"方":{"docs":{},"法":{"docs":{},"块":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"游":{"docs":{},"戏":{"docs":{},"的":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"标":{"docs":{},"签":{"docs":{},"名":{"docs":{},"g":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"判":{"docs":{},"断":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"语":{"docs":{},"法":{"docs":{},"，":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"规":{"docs":{},"则":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"另":{"docs":{},"外":{"docs":{},"一":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"是":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"它":{"docs":{},"和":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"的":{"docs":{},"区":{"docs":{},"别":{"docs":{},"是":{"docs":{},"在":{"docs":{},"判":{"docs":{},"断":{"docs":{},"循":{"docs":{},"环":{"docs":{},"条":{"docs":{},"件":{"docs":{},"之":{"docs":{},"前":{"docs":{},"，":{"docs":{},"先":{"docs":{},"执":{"docs":{},"行":{"docs":{},"一":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"块":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"重":{"docs":{},"复":{"docs":{},"循":{"docs":{},"环":{"docs":{},"直":{"docs":{},"到":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"运":{"docs":{},"行":{"docs":{},"一":{"docs":{},"系":{"docs":{},"列":{"docs":{},"语":{"docs":{},"句":{"docs":{},"直":{"docs":{},"到":{"docs":{},"条":{"docs":{},"件":{"docs":{},"变":{"docs":{},"成":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"。":{"docs":{},"这":{"docs":{},"类":{"docs":{},"循":{"docs":{},"环":{"docs":{},"适":{"docs":{},"合":{"docs":{},"使":{"docs":{},"用":{"docs":{},"在":{"docs":{},"第":{"docs":{},"一":{"docs":{},"次":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"前":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"次":{"docs":{},"数":{"docs":{},"未":{"docs":{},"知":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396}}}}}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"o":{"docs":{},"r":{"docs":{},"l":{"docs":{},"d":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.01696969696969697},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.01707317073170732},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"<":{"docs":{},"/":{"docs":{},"p":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}},"k":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"d":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.012903225806451613}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"c":{"docs":{},"h":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}},"r":{"docs":{},"m":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}},"v":{"docs":{},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"b":{"docs":{},"y":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}},"n":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.01808785529715762},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"=":{"docs":{},"\"":{"1":{"6":{"9":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}},"docs":{}},"2":{"4":{"3":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}},"5":{"2":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}},"docs":{}},"3":{"8":{"8":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}},"docs":{}},"docs":{}},"docs":{}}},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"两":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}}},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"例":{"docs":{},"子":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"和":{"docs":{},"圆":{"docs":{},"括":{"docs":{},"号":{"docs":{},"的":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"写":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"名":{"docs":{},"，":{"docs":{},"它":{"docs":{},"就":{"docs":{},"会":{"docs":{},"作":{"docs":{},"为":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"不":{"docs":{},"写":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"会":{"docs":{},"将":{"docs":{},"新":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"固":{"docs":{},"定":{"docs":{},"参":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"，":{"docs":{},"在":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"代":{"docs":{},"码":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"指":{"docs":{},"定":{"docs":{},"则":{"docs":{},"参":{"docs":{},"数":{"docs":{},"仍":{"docs":{},"然":{"docs":{},"可":{"docs":{},"用":{"docs":{},"，":{"docs":{},"这":{"docs":{},"时":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"名":{"docs":{},"称":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"表":{"docs":{},"示":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}},"初":{"docs":{},"始":{"docs":{},"名":{"docs":{},"为":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"初":{"docs":{},"始":{"docs":{},"名":{"docs":{},"为":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"只":{"docs":{},"有":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"或":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"被":{"docs":{},"改":{"docs":{},"变":{"docs":{},"之":{"docs":{},"前":{"docs":{},"运":{"docs":{},"行":{"docs":{},"。":{"docs":{},"新":{"docs":{},"的":{"docs":{},"值":{"docs":{},"作":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"常":{"docs":{},"量":{"docs":{},"经":{"docs":{},"过":{"docs":{},"过":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"改":{"docs":{},"变":{"docs":{},"它":{"docs":{},"。":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"监":{"docs":{},"视":{"docs":{},"器":{"docs":{},"在":{"docs":{},"变":{"docs":{},"量":{"docs":{},"或":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"被":{"docs":{},"改":{"docs":{},"变":{"docs":{},"后":{"docs":{},"立":{"docs":{},"即":{"docs":{},"运":{"docs":{},"行":{"docs":{},"。":{"docs":{},"和":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"语":{"docs":{},"句":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"在":{"docs":{},"你":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"语":{"docs":{},"句":{"docs":{},"时":{"docs":{},"，":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.00927643784786642}},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"所":{"docs":{},"能":{"docs":{},"承":{"docs":{},"载":{"docs":{},"的":{"docs":{},"最":{"docs":{},"大":{"docs":{},"值":{"2":{"5":{"5":{"docs":{},"(":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"1":{"docs":{},")":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"用":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"+":{"docs":{},"加":{"1":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"就":{"docs":{},"无":{"docs":{},"法":{"docs":{},"表":{"docs":{},"达":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"的":{"docs":{},"二":{"docs":{},"进":{"docs":{},"制":{"docs":{},"了":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"导":{"docs":{},"致":{"docs":{},"了":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"上":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"了":{"docs":{},"，":{"docs":{},"大":{"docs":{},"家":{"docs":{},"可":{"docs":{},"以":{"docs":{},"看":{"docs":{},"下":{"docs":{},"图":{"docs":{},"。":{"docs":{},"溢":{"docs":{},"出":{"docs":{},"后":{"docs":{},"，":{"docs":{},"新":{"docs":{},"值":{"docs":{},"在":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"的":{"docs":{},"承":{"docs":{},"载":{"docs":{},"范":{"docs":{},"围":{"docs":{},"内":{"docs":{},"的":{"docs":{},"那":{"docs":{},"部":{"docs":{},"分":{"docs":{},"是":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}},"docs":{}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.00927643784786642}}}}}}}}}}}},"d":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}}}}},"h":{"docs":{},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"y":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"形":{"docs":{},"参":{"docs":{},"c":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.006060606060606061}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.4675405214940099},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}},"i":{"docs":{},"n":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.8746672582076308}}}},"，":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"，":{"docs":{},"b":{"docs":{},"y":{"docs":{},"等":{"docs":{},"等":{"docs":{},"。":{"docs":{},"前":{"docs":{},"面":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"类":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"就":{"docs":{},"是":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"介":{"docs":{},"词":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"让":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"能":{"docs":{},"像":{"docs":{},"一":{"docs":{},"个":{"docs":{},"句":{"docs":{},"子":{"docs":{},"一":{"docs":{},"样":{"docs":{},"被":{"docs":{},"解":{"docs":{},"读":{"docs":{},"。":{"docs":{},"和":{"docs":{},"函":{"docs":{},"数":{"docs":{},"参":{"docs":{},"数":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}},"e":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.007317073170731708}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}},"e":{"docs":{},"变":{"docs":{},"量":{"docs":{},"添":{"docs":{},"加":{"docs":{},"了":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"注":{"docs":{},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"这":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.010476190476190476}}},"k":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"或":{"docs":{},"者":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"和":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"如":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"或":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615}}}},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"x":{"2":{"4":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.046511627906976744},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.01619047619047619},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.02295918367346939},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.012195121951219513},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.009191176470588236},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.00927643784786642},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.015810276679841896},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.03065134099616858},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}},"i":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}}}}},"h":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}},".":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"e":{"docs":{},"p":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"将":{"docs":{},"会":{"docs":{},"输":{"docs":{},"出":{"docs":{},"内":{"docs":{},"容":{"docs":{},"到":{"docs":{},"“":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"”":{"docs":{},"面":{"docs":{},"板":{"docs":{},"上":{"docs":{},"。":{"docs":{},"(":{"docs":{},"另":{"docs":{},"一":{"docs":{},"种":{"docs":{},"函":{"docs":{},"数":{"docs":{},"叫":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"n":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"n":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"-":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}}},"和":{"docs":{},"y":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}},"的":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"，":{"docs":{},"用":{"docs":{},"于":{"docs":{},"临":{"docs":{},"时":{"docs":{},"获":{"docs":{},"取":{"docs":{},"元":{"docs":{},"组":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"常":{"docs":{},"量":{"docs":{},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"一":{"docs":{},"部":{"docs":{},"分":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"动":{"docs":{},"态":{"docs":{},"的":{"docs":{},"过":{"docs":{},"滤":{"docs":{},"器":{"docs":{},"(":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{},"。":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"y":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}},"和":{"docs":{},"z":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"三":{"docs":{},"者":{"docs":{},"均":{"docs":{},"为":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}},"都":{"docs":{},"指":{"docs":{},"的":{"docs":{},"是":{"docs":{},"名":{"docs":{},"称":{"docs":{},"为":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}},"相":{"docs":{},"加":{"docs":{},"，":{"docs":{},"把":{"docs":{},"向":{"docs":{},"量":{"docs":{},"的":{"docs":{},"y":{"docs":{},"相":{"docs":{},"减":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"实":{"docs":{},"际":{"docs":{},"是":{"docs":{},"属":{"docs":{},"于":{"docs":{},"加":{"docs":{},"减":{"docs":{},"运":{"docs":{},"算":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"让":{"docs":{},"它":{"docs":{},"保":{"docs":{},"持":{"docs":{},"了":{"docs":{},"和":{"docs":{},"加":{"docs":{},"法":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"和":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"和":{"1":{"4":{"0":{"docs":{},")":{"docs":{},"。":{"docs":{},"查":{"docs":{},"阅":{"docs":{},"完":{"docs":{},"整":{"docs":{},"的":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}},"没":{"docs":{},"有":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"y":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"y":{"1":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"2":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.02},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.013333333333333334},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.03571428571428571},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.009191176470588236},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.008908685968819599},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.014367816091954023},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.03525046382189239},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.010869565217391304},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.022988505747126436},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.022900763358778626},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}},"e":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"a":{"docs":{},"h":{"docs":{},"d":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"c":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372}}}}}}}}}},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"k":{"docs":{},"u":{"docs":{},"g":{"docs":{},"e":{"docs":{},"m":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02}}}}}}},"'":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}},")":{"docs":{},"声":{"docs":{},"明":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"余":{"docs":{},"下":{"docs":{},"所":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{},"这":{"docs":{},"使":{"docs":{},"得":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"将":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"横":{"docs":{},"坐":{"docs":{},"标":{"docs":{},"为":{"0":{"docs":{},"的":{"docs":{},"点":{"docs":{},"，":{"docs":{},"并":{"docs":{},"把":{"docs":{},"这":{"docs":{},"个":{"docs":{},"点":{"docs":{},"的":{"docs":{},"纵":{"docs":{},"坐":{"docs":{},"标":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"临":{"docs":{},"时":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"y":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},":":{"docs":{},"和":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}},"中":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"，":{"docs":{},"只":{"docs":{},"要":{"docs":{},"某":{"docs":{},"个":{"docs":{},"元":{"docs":{},"组":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"且":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"分":{"docs":{},"配":{"docs":{},"到":{"docs":{},"各":{"docs":{},"个":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"种":{"docs":{},"行":{"docs":{},"为":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"元":{"docs":{},"组":{"docs":{},"(":{"1":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}},"docs":{}}}}}}}}},"-":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}},"上":{"docs":{},"，":{"docs":{},"是":{"docs":{},"否":{"docs":{},"在":{"docs":{},"紫":{"docs":{},"色":{"docs":{},"的":{"docs":{},"对":{"docs":{},"角":{"docs":{},"线":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}},"是":{"docs":{},"错":{"docs":{},"误":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}},"z":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"q":{"5":{"4":{"docs":{},"z":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{"index.html#gitbook_6465":{"ref":"index.html#gitbook_6465","tf":0.02},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}},"docs":{}},"docs":{}},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.02666666666666667}},"）":{"docs":{},"这":{"docs":{},"一":{"docs":{},"机":{"docs":{},"制":{"docs":{},"来":{"docs":{},"跟":{"docs":{},"踪":{"docs":{},"和":{"docs":{},"管":{"docs":{},"理":{"docs":{},"你":{"docs":{},"的":{"docs":{},"应":{"docs":{},"用":{"docs":{},"程":{"docs":{},"序":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.00842358604091456},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},":":{"docs":{},"≈":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"3":{"docs":{},"d":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"[":{"0":{"docs":{},"]":{"docs":{},"是":{"docs":{},"指":{"docs":{},"[":{"docs":{},"[":{"1":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}},"docs":{}}}}}}},"docs":{}}}},"docs":{},"和":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},"替":{"docs":{},"代":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"形":{"docs":{},"参":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}},"类":{"docs":{},"型":{"docs":{},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"以":{"docs":{},"创":{"docs":{},"建":{"docs":{},"特":{"docs":{},"定":{"docs":{},"大":{"docs":{},"小":{"docs":{},"并":{"docs":{},"且":{"docs":{},"所":{"docs":{},"有":{"docs":{},"数":{"docs":{},"据":{"docs":{},"都":{"docs":{},"被":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"方":{"docs":{},"法":{"docs":{},"。":{"docs":{},"我":{"docs":{},"们":{"docs":{},"可":{"docs":{},"以":{"docs":{},"把":{"docs":{},"准":{"docs":{},"备":{"docs":{},"加":{"docs":{},"入":{"docs":{},"新":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"数":{"docs":{},"量":{"docs":{},"（":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"）":{"docs":{},"和":{"docs":{},"适":{"docs":{},"当":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}},"更":{"docs":{},"多":{"docs":{},"限":{"docs":{},"制":{"docs":{},"的":{"docs":{},"集":{"docs":{},"合":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"可":{"docs":{},"以":{"docs":{},"允":{"docs":{},"许":{"docs":{},"其":{"docs":{},"里":{"docs":{},"面":{"docs":{},"任":{"docs":{},"何":{"docs":{},"位":{"docs":{},"置":{"docs":{},"的":{"docs":{},"插":{"docs":{},"入":{"docs":{},"/":{"docs":{},"删":{"docs":{},"除":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"而":{"docs":{},"栈":{"docs":{},"，":{"docs":{},"只":{"docs":{},"允":{"docs":{},"许":{"docs":{},"在":{"docs":{},"集":{"docs":{},"合":{"docs":{},"的":{"docs":{},"末":{"docs":{},"端":{"docs":{},"添":{"docs":{},"加":{"docs":{},"新":{"docs":{},"的":{"docs":{},"项":{"docs":{},"（":{"docs":{},"如":{"docs":{},"同":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"值":{"docs":{},"进":{"docs":{},"栈":{"docs":{},"）":{"docs":{},"。":{"docs":{},"同":{"docs":{},"样":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"栈":{"docs":{},"也":{"docs":{},"只":{"docs":{},"能":{"docs":{},"从":{"docs":{},"末":{"docs":{},"端":{"docs":{},"移":{"docs":{},"除":{"docs":{},"项":{"docs":{},"（":{"docs":{},"如":{"docs":{},"同":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"和":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}},"s":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"和":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"行":{"docs":{},"为":{"docs":{},"要":{"docs":{},"比":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"的":{"docs":{},"多":{"docs":{},"。":{"docs":{},"当":{"docs":{},"操":{"docs":{},"作":{"docs":{},"数":{"docs":{},"组":{"docs":{},"内":{"docs":{},"容":{"docs":{},"时":{"docs":{},"，":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},")":{"docs":{},"能":{"docs":{},"提":{"docs":{},"供":{"docs":{},"接":{"docs":{},"近":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}},"性":{"docs":{},"质":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"存":{"docs":{},"储":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"提":{"docs":{},"供":{"docs":{},"两":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"：":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"，":{"docs":{},"从":{"docs":{},"栈":{"docs":{},"中":{"docs":{},"压":{"docs":{},"进":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"和":{"docs":{},"移":{"docs":{},"除":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"方":{"docs":{},"法":{"docs":{},"标":{"docs":{},"记":{"docs":{},"为":{"docs":{},"可":{"docs":{},"变":{"docs":{},"的":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"他":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"修":{"docs":{},"改":{"docs":{},"（":{"docs":{},"或":{"docs":{},"转":{"docs":{},"换":{"docs":{},"）":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.00410958904109589}},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5585406301824213},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.011857707509881422},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"y":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}},"i":{"docs":{},"c":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"1":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}},"3":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}},"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}}}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}},"o":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}},"x":{"docs":{},"o":{"docs":{},"r":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"2":{"docs":{},"x":{"docs":{},".":{"docs":{},"p":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.017817371937639197}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}},"i":{"docs":{},"c":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.01098901098901099}},"的":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"就":{"docs":{},"会":{"docs":{},"自":{"docs":{},"动":{"docs":{},"地":{"docs":{},"设":{"docs":{},"置":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"为":{"docs":{},"新":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"选":{"docs":{},"择":{"docs":{},"一":{"docs":{},"个":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"。":{"docs":{},"具":{"docs":{},"体":{"docs":{},"来":{"docs":{},"说":{"docs":{},"就":{"docs":{},"是":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"将":{"docs":{},"新":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"值":{"docs":{},"除":{"docs":{},"以":{"1":{"0":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"向":{"docs":{},"下":{"docs":{},"取":{"docs":{},"得":{"docs":{},"最":{"docs":{},"接":{"docs":{},"近":{"docs":{},"的":{"docs":{},"整":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"最":{"docs":{},"后":{"docs":{},"加":{"1":{"docs":{},"来":{"docs":{},"得":{"docs":{},"到":{"docs":{},"档":{"docs":{},"位":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"速":{"docs":{},"度":{"docs":{},"为":{"1":{"0":{"docs":{},".":{"0":{"docs":{},"时":{"docs":{},"，":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"为":{"1":{"docs":{},"；":{"docs":{},"速":{"docs":{},"度":{"docs":{},"为":{"3":{"5":{"docs":{},".":{"0":{"docs":{},"时":{"docs":{},"，":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"为":{"4":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}},"docs":{}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}},"docs":{}}}}}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"是":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"。":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"表":{"docs":{},"示":{"docs":{},"自":{"docs":{},"动":{"docs":{},"挡":{"docs":{},"汽":{"docs":{},"车":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"根":{"docs":{},"据":{"docs":{},"当":{"docs":{},"前":{"docs":{},"的":{"docs":{},"速":{"docs":{},"度":{"docs":{},"自":{"docs":{},"动":{"docs":{},"选":{"docs":{},"择":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"挡":{"docs":{},"位":{"docs":{},"。":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"见":{"docs":{},"类":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"章":{"docs":{},"节":{"docs":{},"）":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"动":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"函":{"docs":{},"数":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"特":{"docs":{},"定":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"上":{"docs":{},"的":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"而":{"docs":{},"非":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"本":{"docs":{},"身":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"_":{"docs":{},"c":{"docs":{},"l":{"docs":{},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"来":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"别":{"docs":{},"名":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"是":{"docs":{},"别":{"docs":{},"名":{"docs":{},"，":{"docs":{},"a":{"docs":{},"u":{"docs":{},"d":{"docs":{},"i":{"docs":{},"o":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"是":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"1":{"6":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"会":{"docs":{},"给":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"u":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"赋":{"docs":{},"一":{"docs":{},"个":{"docs":{},"初":{"docs":{},"值":{"0":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.011111111111111112}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}}}}}}}}}}},"也":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"表":{"docs":{},"示":{"docs":{},"立":{"docs":{},"体":{"docs":{},"声":{"docs":{},"系":{"docs":{},"统":{"docs":{},"的":{"docs":{},"两":{"docs":{},"个":{"docs":{},"声":{"docs":{},"道":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{},"和":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"4":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},"b":{"docs":{},"）":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"从":{"docs":{},"a":{"docs":{},"到":{"docs":{},"b":{"docs":{},"(":{"docs":{},"包":{"docs":{},"括":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"和":{"docs":{},"a":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}},"）":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"从":{"docs":{},"a":{"docs":{},"到":{"docs":{},"b":{"docs":{},"但":{"docs":{},"不":{"docs":{},"包":{"docs":{},"括":{"docs":{},"b":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.023622047244094488}},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"t":{"1":{"docs":{},"s":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}}}}}}}},"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.024163568773234202}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}},"e":{"docs":{},"r":{"docs":{},"常":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"。":{"docs":{},"它":{"docs":{},"已":{"docs":{},"经":{"docs":{},"被":{"docs":{},"可":{"docs":{},"选":{"docs":{},"包":{"docs":{},"含":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"过":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"再":{"docs":{},"使":{"docs":{},"用":{"docs":{},"!":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"在":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"才":{"docs":{},"会":{"docs":{},"被":{"docs":{},"执":{"docs":{},"行":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}},"d":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"o":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.007272727272727273}},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}},"，":{"docs":{},"并":{"docs":{},"输":{"docs":{},"出":{"docs":{},"结":{"docs":{},"果":{"docs":{},"：":{"8":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}},"docs":{}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},"(":{"5":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}},"docs":{},"a":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.022292993630573247}},"。":{"docs":{},"它":{"docs":{},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"他":{"docs":{},"们":{"docs":{},"额":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},"。":{"docs":{},"前":{"docs":{},"面":{"docs":{},"两":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"的":{"docs":{},"使":{"docs":{},"用":{"docs":{},"（":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"。":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"你":{"docs":{},"需":{"docs":{},"要":{"docs":{},"在":{"docs":{},"它":{"docs":{},"获":{"docs":{},"取":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"的":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}},"还":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"检":{"docs":{},"查":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"有":{"docs":{},"值":{"docs":{},"则":{"docs":{},"将":{"docs":{},"其":{"docs":{},"返":{"docs":{},"回":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"如":{"docs":{},"果":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"设":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"实":{"docs":{},"例":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"并":{"docs":{},"为":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.006857142857142857}}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.008955223880597015},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364}}}}}}},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"并":{"docs":{},"存":{"docs":{},"储":{"docs":{},"了":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"副":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"该":{"docs":{},"副":{"docs":{},"本":{"docs":{},"随":{"docs":{},"着":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"者":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"来":{"docs":{},"声":{"docs":{},"明":{"docs":{},"在":{"docs":{},"嵌":{"docs":{},"入":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"表":{"docs":{},"示":{"docs":{},"每":{"docs":{},"次":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"默":{"docs":{},"认":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}},"当":{"docs":{},"作":{"docs":{},"一":{"docs":{},"个":{"docs":{},"局":{"docs":{},"部":{"docs":{},"名":{"docs":{},"称":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"把":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.011131725417439703},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.00691699604743083},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},";":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.007317073170731708},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},";":{"docs":{},"和":{"docs":{},"|":{"docs":{},"|":{"docs":{},"的":{"docs":{},"复":{"docs":{},"合":{"docs":{},"逻":{"docs":{},"辑":{"docs":{},"。":{"docs":{},"但":{"docs":{},"无":{"docs":{},"论":{"docs":{},"怎":{"docs":{},"样":{"docs":{},"，":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"和":{"docs":{},"&":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},";":{"docs":{},"%":{"docs":{},"进":{"docs":{},"行":{"docs":{},"除":{"0":{"docs":{},"操":{"docs":{},"作":{"docs":{},"时":{"docs":{},"就":{"docs":{},"会":{"docs":{},"得":{"docs":{},"到":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}},"­":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"格":{"docs":{},"式":{"docs":{},"进":{"docs":{},"行":{"docs":{},"组":{"docs":{},"合":{"docs":{},"，":{"docs":{},"称":{"docs":{},"为":{"docs":{},"协":{"docs":{},"议":{"docs":{},"合":{"docs":{},"成":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.006564551422319475}}}}}}}}}}},"w":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}}}},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"c":{"2":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.009696969696969697},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.014059753954305799}}}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}},"n":{"docs":{},"y":{"docs":{},"m":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"[":{"1":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}}}}}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"可":{"docs":{},"以":{"docs":{},"代":{"docs":{},"表":{"docs":{},"任":{"docs":{},"何":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"表":{"docs":{},"示":{"docs":{},"任":{"docs":{},"何":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"除":{"docs":{},"了":{"docs":{},"方":{"docs":{},"法":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}},"a":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}},"i":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"(":{"docs":{},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}},"s":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"s":{"docs":{},"w":{"docs":{},"e":{"docs":{},"r":{"1":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"2":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}}},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.004571428571428572},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.01312910284463895}},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.017142857142857144},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{},"插":{"docs":{},"入":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},",":{"docs":{},"删":{"docs":{},"除":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"或":{"docs":{},"者":{"docs":{},"使":{"docs":{},"用":{"docs":{},"范":{"docs":{},"围":{"docs":{},"下":{"docs":{},"标":{"docs":{},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}}}}}}},"方":{"docs":{},"法":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}},"s":{"docs":{},"，":{"docs":{},"它":{"docs":{},"一":{"docs":{},"般":{"docs":{},"接":{"docs":{},"收":{"docs":{},"一":{"docs":{},"个":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.02095238095238095}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}},"实":{"docs":{},"例":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"叫":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"并":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"的":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"来":{"docs":{},"自":{"docs":{},"于":{"docs":{},"变":{"docs":{},"量":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"7":{"3":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"断":{"docs":{},"开":{"docs":{},"这":{"docs":{},"个":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"再":{"docs":{},"也":{"docs":{},"没":{"docs":{},"有":{"docs":{},"指":{"docs":{},"向":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.007079646017699115},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.007220216606498195}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"字":{"docs":{},"典":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"储":{"docs":{},"存":{"docs":{},"了":{"docs":{},"四":{"docs":{},"个":{"docs":{},"人":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"和":{"docs":{},"年":{"docs":{},"龄":{"docs":{},"。":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"字":{"docs":{},"典":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"的":{"docs":{},"新":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"在":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"的":{"docs":{},"过":{"docs":{},"程":{"docs":{},"中":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"，":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"p":{"docs":{},"i":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"就":{"docs":{},"是":{"docs":{},"给":{"docs":{},"现":{"docs":{},"有":{"docs":{},"类":{"docs":{},"型":{"docs":{},"定":{"docs":{},"义":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"字":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}},"g":{"docs":{},"n":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}},"s":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.007751937984496124}}},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}},"的":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"同":{"docs":{},"时":{"docs":{},"对":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}},"=":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}},"的":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"检":{"docs":{},"查":{"docs":{},"是":{"docs":{},"否":{"docs":{},"两":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"单":{"docs":{},"例":{"docs":{},"包":{"docs":{},"含":{"docs":{},"具":{"docs":{},"有":{"docs":{},"相":{"docs":{},"同":{"docs":{},"顺":{"docs":{},"序":{"docs":{},"的":{"docs":{},"相":{"docs":{},"同":{"docs":{},"元":{"docs":{},"素":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"的":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"首":{"docs":{},"先":{"docs":{},"检":{"docs":{},"查":{"docs":{},"两":{"docs":{},"个":{"docs":{},"容":{"docs":{},"器":{"docs":{},"是":{"docs":{},"否":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"同":{"docs":{},"样":{"docs":{},"数":{"docs":{},"目":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"s":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"他":{"docs":{},"们":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"数":{"docs":{},"目":{"docs":{},"不":{"docs":{},"同":{"docs":{},"，":{"docs":{},"没":{"docs":{},"有":{"docs":{},"办":{"docs":{},"法":{"docs":{},"进":{"docs":{},"行":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"函":{"docs":{},"数":{"docs":{},"就":{"docs":{},"会":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"写":{"docs":{},"一":{"docs":{},"个":{"docs":{},"断":{"docs":{},"言":{"docs":{},"。":{"docs":{},"向":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"函":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"结":{"docs":{},"果":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"以":{"docs":{},"及":{"docs":{},"一":{"docs":{},"条":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"当":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.005309734513274336}}}}}}}}},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.006423982869379015},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},"的":{"docs":{},"值":{"docs":{},"可":{"docs":{},"取":{"docs":{},"的":{"docs":{},"值":{"docs":{},"有":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"，":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"和":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}},"默":{"docs":{},"认":{"docs":{},"为":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"，":{"docs":{},"优":{"docs":{},"先":{"docs":{},"级":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},"默":{"docs":{},"认":{"docs":{},"为":{"1":{"0":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"­":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"并":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"(":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},"一":{"docs":{},"起":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"一":{"docs":{},"个":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"，":{"docs":{},"其":{"docs":{},"中":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"可":{"docs":{},"以":{"docs":{},"说":{"docs":{},"是":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"，":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"或":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"一":{"docs":{},"个":{"docs":{},"。":{"docs":{},"左":{"docs":{},"结":{"docs":{},"合":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"以":{"docs":{},"从":{"docs":{},"左":{"docs":{},"到":{"docs":{},"右":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"分":{"docs":{},"组":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"减":{"docs":{},"法":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"(":{"docs":{},"-":{"docs":{},")":{"docs":{},"具":{"docs":{},"有":{"docs":{},"左":{"docs":{},"结":{"docs":{},"合":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"4":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"i":{"docs":{},"d":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"、":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"、":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"、":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"、":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"、":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"、":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"、":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"、":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"、":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},")":{"docs":{},"、":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},")":{"docs":{},"、":{"docs":{},"w":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{},"、":{"docs":{},"w":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":2.004878048780488},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0074211502782931356},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.015810276679841896}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"还":{"docs":{},"需":{"docs":{},"要":{"docs":{},"把":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"左":{"docs":{},"参":{"docs":{},"数":{"docs":{},"设":{"docs":{},"置":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"o":{"docs":{},"l":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"字":{"docs":{},"符":{"docs":{},"型":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"k":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"元":{"docs":{},"素":{"docs":{},"确":{"docs":{},"实":{"docs":{},"需":{"docs":{},"要":{"docs":{},"处":{"docs":{},"理":{"docs":{},"为":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"输":{"docs":{},"出":{"docs":{},"的":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"时":{"docs":{},"，":{"docs":{},"才":{"docs":{},"需":{"docs":{},"要":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"。":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"在":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"中":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"只":{"docs":{},"有":{"docs":{},"当":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"完":{"docs":{},"成":{"docs":{},"以":{"docs":{},"及":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"确":{"docs":{},"实":{"docs":{},"存":{"docs":{},"在":{"docs":{},"后":{"docs":{},"，":{"docs":{},"才":{"docs":{},"能":{"docs":{},"访":{"docs":{},"问":{"docs":{},"l":{"docs":{},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"由":{"docs":{},"于":{"docs":{},"a":{"docs":{},"s":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}},"持":{"docs":{},"有":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"的":{"docs":{},"强":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"，":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"在":{"docs":{},"其":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"体":{"docs":{},"内":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"（":{"docs":{},"引":{"docs":{},"用":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},".":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"）":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"占":{"docs":{},"有":{"docs":{},"了":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"，":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"闭":{"docs":{},"包":{"docs":{},"又":{"docs":{},"反":{"docs":{},"过":{"docs":{},"来":{"docs":{},"持":{"docs":{},"有":{"docs":{},"了":{"docs":{},"h":{"docs":{},"t":{"docs":{},"m":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"下":{"docs":{},"转":{"docs":{},"并":{"docs":{},"解":{"docs":{},"包":{"docs":{},"到":{"docs":{},"不":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"p":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}},"?":{"docs":{},")":{"docs":{},"。":{"docs":{},"可":{"docs":{},"选":{"docs":{},"形":{"docs":{},"式":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"检":{"docs":{},"查":{"docs":{},"总":{"docs":{},"是":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"（":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}}}}}}}}}}}}}}}},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"，":{"docs":{},"当":{"docs":{},"实":{"docs":{},"例":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"协":{"docs":{},"议":{"docs":{},"时":{"docs":{},"，":{"docs":{},"返":{"docs":{},"回":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"类":{"docs":{},"型":{"docs":{},"；":{"docs":{},"否":{"docs":{},"则":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}}}}}},"­":{"docs":{},"?":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}},"、":{"docs":{},"d":{"docs":{},"y":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"、":{"docs":{},"i":{"docs":{},"s":{"docs":{},"、":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"、":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"、":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"f":{"docs":{},"、":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{},"_":{"docs":{},"、":{"docs":{},"_":{"docs":{},"_":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{},"_":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"右":{"docs":{},"边":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"那":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"。":{"docs":{},"一":{"docs":{},"旦":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"成":{"docs":{},"功":{"docs":{},"，":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0350109409190372}},"'":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0175054704595186}}}}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"[":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}},"l":{"docs":{},"h":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}},"字":{"docs":{},"典":{"docs":{},"使":{"docs":{},"用":{"docs":{},"字":{"docs":{},"典":{"docs":{},"字":{"docs":{},"面":{"docs":{},"语":{"docs":{},"句":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"，":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"第":{"docs":{},"一":{"docs":{},"对":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"t":{"docs":{},"y":{"docs":{},"o":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"t":{"docs":{},"o":{"docs":{},"k":{"docs":{},"y":{"docs":{},"o":{"docs":{},"。":{"docs":{},"第":{"docs":{},"二":{"docs":{},"对":{"docs":{},"的":{"docs":{},"键":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"，":{"docs":{},"值":{"docs":{},"是":{"docs":{},"d":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"变":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"）":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"一":{"docs":{},"种":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.05263157894736842},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.011777301927194861},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.02054794520547945}},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}}}}}},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"­":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"­":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"­":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"g":{"docs":{},"h":{"docs":{},"i":{"docs":{},"j":{"docs":{},"k":{"docs":{},"l":{"docs":{},"m":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667}}}}}}}}}}}}}}}}},",":{"docs":{},"b":{"docs":{},",":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}},"[":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}},"docs":{}},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"值":{"docs":{},"的":{"docs":{},"话":{"docs":{},"，":{"docs":{},"a":{"docs":{},"将":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"与":{"docs":{},"b":{"docs":{},"，":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}},"+":{"docs":{},"+":{"docs":{},"，":{"docs":{},"是":{"docs":{},"先":{"docs":{},"返":{"docs":{},"回":{"docs":{},"了":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"a":{"docs":{},"才":{"docs":{},"加":{"1":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"c":{"docs":{},"得":{"docs":{},"到":{"docs":{},"了":{"docs":{},"a":{"docs":{},"的":{"docs":{},"旧":{"docs":{},"值":{"1":{"docs":{},"，":{"docs":{},"而":{"docs":{},"a":{"docs":{},"加":{"1":{"docs":{},"后":{"docs":{},"变":{"docs":{},"成":{"2":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"docs":{}}}}},"docs":{}}}}}},"docs":{}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},".":{"docs":{},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},"b":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"先":{"docs":{},"把":{"docs":{},"a":{"docs":{},"加":{"1":{"docs":{},"了":{"docs":{},"再":{"docs":{},"返":{"docs":{},"回":{"docs":{},"a":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"所":{"docs":{},"以":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"都":{"docs":{},"是":{"docs":{},"新":{"docs":{},"值":{"1":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"）":{"docs":{},"。":{"docs":{},"一":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"分":{"docs":{},"前":{"docs":{},"置":{"docs":{},"符":{"docs":{},"和":{"docs":{},"后":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"前":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"需":{"docs":{},"紧":{"docs":{},"排":{"docs":{},"操":{"docs":{},"作":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"前":{"docs":{},"（":{"docs":{},"如":{"docs":{},"!":{"docs":{},"b":{"docs":{},"）":{"docs":{},"，":{"docs":{},"后":{"docs":{},"置":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"需":{"docs":{},"紧":{"docs":{},"跟":{"docs":{},"操":{"docs":{},"作":{"docs":{},"对":{"docs":{},"象":{"docs":{},"之":{"docs":{},"后":{"docs":{},"（":{"docs":{},"如":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"对":{"docs":{},"一":{"docs":{},"个":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"取":{"docs":{},"反":{"docs":{},"，":{"docs":{},"使":{"docs":{},"得":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"变":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"变":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"b":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"不":{"docs":{},"是":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"那":{"docs":{},"它":{"docs":{},"们":{"docs":{},"俩":{"docs":{},"就":{"docs":{},"不":{"docs":{},"能":{"docs":{},"互":{"docs":{},"换":{"docs":{},"值":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}}},"？":{"docs":{},"b":{"docs":{},"：":{"docs":{},"c":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.046511627906976744},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"f":{"docs":{},"和":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"来":{"docs":{},"处":{"docs":{},"理":{"docs":{},"值":{"docs":{},"缺":{"docs":{},"失":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"。":{"docs":{},"有":{"docs":{},"些":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"值":{"docs":{},"可":{"docs":{},"能":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"值":{"docs":{},"或":{"docs":{},"者":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"来":{"docs":{},"进":{"docs":{},"行":{"docs":{},"条":{"docs":{},"件":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"i":{"docs":{},"n":{"docs":{},"、":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"、":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"-":{"docs":{},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"，":{"docs":{},"条":{"docs":{},"件":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"—":{"docs":{},"—":{"docs":{},"这":{"docs":{},"意":{"docs":{},"味":{"docs":{},"着":{"docs":{},"像":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}},"条":{"docs":{},"件":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}},"来":{"docs":{},"判":{"docs":{},"断":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"是":{"docs":{},"否":{"docs":{},"包":{"docs":{},"含":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"可":{"docs":{},"选":{"docs":{},"有":{"docs":{},"值":{"docs":{},"，":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"；":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"值":{"docs":{},"，":{"docs":{},"结":{"docs":{},"果":{"docs":{},"是":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"分":{"docs":{},"支":{"docs":{},"中":{"docs":{},"操":{"docs":{},"作":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"改":{"docs":{},"成":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"允":{"docs":{},"许":{"docs":{},"二":{"docs":{},"选":{"docs":{},"一":{"docs":{},"，":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"当":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"通":{"docs":{},"常":{"docs":{},"，":{"docs":{},"当":{"docs":{},"条":{"docs":{},"件":{"docs":{},"较":{"docs":{},"为":{"docs":{},"简":{"docs":{},"单":{"docs":{},"且":{"docs":{},"可":{"docs":{},"能":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"很":{"docs":{},"少":{"docs":{},"时":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"f":{"docs":{},"语":{"docs":{},"句":{"docs":{},"。":{"docs":{},"而":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"更":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"条":{"docs":{},"件":{"docs":{},"较":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"、":{"docs":{},"可":{"docs":{},"能":{"docs":{},"情":{"docs":{},"况":{"docs":{},"较":{"docs":{},"多":{"docs":{},"且":{"docs":{},"需":{"docs":{},"要":{"docs":{},"用":{"docs":{},"到":{"docs":{},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"（":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"-":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"最":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"形":{"docs":{},"式":{"docs":{},"就":{"docs":{},"是":{"docs":{},"只":{"docs":{},"包":{"docs":{},"含":{"docs":{},"一":{"docs":{},"个":{"docs":{},"条":{"docs":{},"件":{"docs":{},"，":{"docs":{},"当":{"docs":{},"且":{"docs":{},"仅":{"docs":{},"当":{"docs":{},"该":{"docs":{},"条":{"docs":{},"件":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"于":{"docs":{},"判":{"docs":{},"断":{"docs":{},"是":{"docs":{},"不":{"docs":{},"是":{"docs":{},"特":{"docs":{},"别":{"docs":{},"热":{"docs":{},"。":{"docs":{},"而":{"docs":{},"最":{"docs":{},"后":{"docs":{},"的":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"似":{"docs":{},"。":{"docs":{},"与":{"docs":{},"之":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"是":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}},"或":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}},"！":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}},"-":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.008403361344537815}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.9100432900432901},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}},"l":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.008849557522123894},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}},"y":{"docs":{},"-":{"docs":{},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"<":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786}}}}}}}}}}}}}}}},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.007494646680942184},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"-":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},".":{"docs":{},"­":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762}}}},"g":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"(":{"7":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343}},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"b":{"docs":{},"y":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.020895522388059702}},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"，":{"docs":{},"该":{"docs":{},"常":{"docs":{},"量":{"docs":{},"指":{"docs":{},"向":{"docs":{},"一":{"docs":{},"个":{"docs":{},"每":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"会":{"docs":{},"加":{"1":{"0":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.014925373134328358}},"从":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"中":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"和":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"获":{"docs":{},"取":{"docs":{},"任":{"docs":{},"何":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"但":{"docs":{},"是":{"docs":{},"在":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"内":{"docs":{},"访":{"docs":{},"问":{"docs":{},"了":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"和":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"是":{"docs":{},"因":{"docs":{},"为":{"docs":{},"其":{"docs":{},"通":{"docs":{},"过":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"在":{"docs":{},"包":{"docs":{},"含":{"docs":{},"它":{"docs":{},"的":{"docs":{},"函":{"docs":{},"数":{"docs":{},"体":{"docs":{},"内":{"docs":{},"已":{"docs":{},"经":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"和":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"其":{"docs":{},"会":{"docs":{},"以":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"作":{"docs":{},"为":{"docs":{},"增":{"docs":{},"量":{"docs":{},"增":{"docs":{},"加":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"其":{"docs":{},"会":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"属":{"docs":{},"于":{"docs":{},"自":{"docs":{},"己":{"docs":{},"的":{"docs":{},"独":{"docs":{},"立":{"docs":{},"的":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}}}},"不":{"docs":{},"能":{"docs":{},"被":{"docs":{},"调":{"docs":{},"用":{"docs":{},"时":{"docs":{},"，":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"属":{"docs":{},"性":{"docs":{},"`":{"docs":{},"`":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"后":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"型":{"docs":{},"可":{"docs":{},"选":{"docs":{},"值":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"方":{"docs":{},"法":{"docs":{},"通":{"docs":{},"过":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"，":{"docs":{},"尝":{"docs":{},"试":{"docs":{},"从":{"docs":{},"两":{"docs":{},"种":{"docs":{},"可":{"docs":{},"选":{"docs":{},"成":{"docs":{},"员":{"docs":{},"中":{"docs":{},"获":{"docs":{},"取":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"转":{"docs":{},"到":{"docs":{},"第":{"2":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}},"docs":{}}}}}}}}}}}}}}}},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.018095238095238095},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.016216216216216217},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.014059753954305799},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"最":{"docs":{},"终":{"docs":{},"的":{"docs":{},"值":{"docs":{},"是":{"3":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"2":{"docs":{},"。":{"docs":{},"最":{"docs":{},"后":{"docs":{},"一":{"docs":{},"次":{"docs":{},"调":{"docs":{},"用":{"docs":{},"递":{"docs":{},"增":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"+":{"docs":{},"+":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"会":{"docs":{},"将":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"设":{"docs":{},"置":{"docs":{},"为":{"3":{"docs":{},"，":{"docs":{},"从":{"docs":{},"而":{"docs":{},"导":{"docs":{},"致":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"docs":{}}}}}}}}}}}},"常":{"docs":{},"量":{"docs":{},"只":{"docs":{},"存":{"docs":{},"在":{"docs":{},"于":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"生":{"docs":{},"命":{"docs":{},"周":{"docs":{},"期":{"docs":{},"里":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"想":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"完":{"docs":{},"成":{"docs":{},"后":{"docs":{},"访":{"docs":{},"问":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"又":{"docs":{},"或":{"docs":{},"者":{"docs":{},"想":{"docs":{},"让":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"每":{"docs":{},"次":{"docs":{},"循":{"docs":{},"环":{"docs":{},"遍":{"docs":{},"历":{"docs":{},"开":{"docs":{},"始":{"docs":{},"时":{"docs":{},"被":{"docs":{},"自":{"docs":{},"动":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"种":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"在":{"docs":{},"使":{"docs":{},"用":{"docs":{},"前":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"它":{"docs":{},"包":{"docs":{},"含":{"docs":{},"在":{"docs":{},"循":{"docs":{},"环":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"中":{"docs":{},"，":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"其":{"docs":{},"进":{"docs":{},"行":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"而":{"docs":{},"无":{"docs":{},"需":{"docs":{},"使":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"被":{"docs":{},"更":{"docs":{},"新":{"docs":{},"为":{"docs":{},"闭":{"docs":{},"区":{"docs":{},"间":{"docs":{},"中":{"docs":{},"的":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"数":{"docs":{},"字":{"docs":{},"（":{"2":{"docs":{},"）":{"docs":{},"，":{"docs":{},"之":{"docs":{},"后":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}}}}}}}},"i":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02197802197802198},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.015238095238095238},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}}}}}},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"i":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}},"r":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}},"o":{"docs":{},"w":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}},"a":{"docs":{},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}},")":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"为":{"docs":{},"新":{"docs":{},"食":{"docs":{},"物":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"占":{"docs":{},"位":{"docs":{},"名":{"docs":{},"字":{"docs":{},"，":{"docs":{},"通":{"docs":{},"过":{"docs":{},"代":{"docs":{},"理":{"docs":{},"调":{"docs":{},"用":{"docs":{},"同":{"docs":{},"一":{"docs":{},"类":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{},")":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"己":{"docs":{},"将":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"的":{"docs":{},"新":{"docs":{},"值":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"到":{"docs":{},"对":{"docs":{},"应":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"中":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"尽":{"docs":{},"量":{"docs":{},"利":{"docs":{},"用":{"docs":{},"现":{"docs":{},"有":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"和":{"docs":{},"它":{"docs":{},"所":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"功":{"docs":{},"能":{"docs":{},"来":{"docs":{},"实":{"docs":{},"现":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"a":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}},"k":{"docs":{},"e":{"docs":{},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"l":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"i":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.8370098039215685},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.007905138339920948},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.01284796573875803},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"a":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"l":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},")":{"docs":{},"和":{"docs":{},"成":{"docs":{},"员":{"docs":{},"级":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"(":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}},"）":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"对":{"docs":{},"于":{"docs":{},"来":{"docs":{},"自":{"docs":{},"你":{"docs":{},"的":{"docs":{},"扩":{"docs":{},"展":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"的":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"调":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"(":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"­":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"e":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"b":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"用":{"docs":{},"来":{"docs":{},"给":{"docs":{},"某":{"docs":{},"个":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}}}}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}},"s":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"新":{"docs":{},"常":{"docs":{},"量":{"docs":{},"的":{"docs":{},"值":{"docs":{},"等":{"docs":{},"于":{"docs":{},"所":{"docs":{},"有":{"docs":{},"位":{"docs":{},"都":{"docs":{},"取":{"docs":{},"反":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"，":{"docs":{},"即":{"1":{"docs":{},"变":{"docs":{},"成":{"0":{"docs":{},"，":{"0":{"docs":{},"变":{"docs":{},"成":{"1":{"docs":{},"，":{"docs":{},"变":{"docs":{},"成":{"docs":{},"了":{"1":{"1":{"1":{"1":{"0":{"0":{"0":{"0":{"docs":{},"，":{"docs":{},"十":{"docs":{},"进":{"docs":{},"制":{"docs":{},"值":{"docs":{},"为":{"2":{"4":{"0":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}}}},"docs":{}}},"docs":{}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"z":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"、":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"之":{"docs":{},"间":{"docs":{},"的":{"docs":{},"分":{"docs":{},"号":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"包":{"docs":{},"围":{"docs":{},"循":{"docs":{},"环":{"docs":{},"体":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"仅":{"docs":{},"在":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"语":{"docs":{},"句":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"域":{"docs":{},"以":{"docs":{},"内":{"docs":{},"有":{"docs":{},"效":{"docs":{},"。":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"必":{"docs":{},"须":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"之":{"docs":{},"前":{"docs":{},"放":{"docs":{},"置":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}},"，":{"docs":{},"并":{"docs":{},"在":{"docs":{},"里":{"docs":{},"面":{"docs":{},"将":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"3":{"2":{"docs":{},".":{"0":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},"来":{"docs":{},"代":{"docs":{},"替":{"docs":{},"之":{"docs":{},"前":{"docs":{},"版":{"docs":{},"本":{"docs":{},"中":{"docs":{},"的":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"操":{"docs":{},"作":{"docs":{},"。":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"含":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"形":{"docs":{},"参":{"docs":{},"，":{"docs":{},"使":{"docs":{},"得":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"接":{"docs":{},"收":{"docs":{},"任":{"docs":{},"意":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"（":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}},"t":{"1":{"6":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}},"整":{"docs":{},"型":{"docs":{},"能":{"docs":{},"承":{"docs":{},"载":{"docs":{},"的":{"docs":{},"整":{"docs":{},"数":{"docs":{},"范":{"docs":{},"围":{"docs":{},"是":{"docs":{},"-":{"3":{"2":{"7":{"6":{"8":{"docs":{},"到":{"3":{"2":{"7":{"6":{"7":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"8":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}},"i":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"范":{"docs":{},"围":{"docs":{},"是":{"docs":{},"-":{"1":{"2":{"8":{"docs":{},"~":{"1":{"2":{"7":{"docs":{},"，":{"docs":{},"而":{"docs":{},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"8":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"能":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"范":{"docs":{},"围":{"docs":{},"是":{"0":{"docs":{},"~":{"2":{"5":{"5":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.024},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.007326007326007326},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.02654867256637168},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.015317286652078774},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.07636363636363637},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.01791044776119403},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.022222222222222223},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.02806122448979592},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.10270270270270271},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.03870967741935484},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.015238095238095238},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.009554140127388535},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.047244094488188976},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.014367816091954023},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.02045728038507822},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.043936731107205626},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.06406685236768803},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.007905138339920948},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.011777301927194861},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.03065134099616858},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.28757302177376526},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"把":{"docs":{},"常":{"docs":{},"量":{"docs":{},"名":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"名":{"docs":{},"当":{"docs":{},"做":{"docs":{},"占":{"docs":{},"位":{"docs":{},"符":{"docs":{},"加":{"docs":{},"入":{"docs":{},"到":{"docs":{},"长":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"中":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.010940919037199124}}},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":5.021052631578947}}}}}},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.010619469026548672},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.004761904761904762},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"属":{"docs":{},"于":{"docs":{},"列":{"docs":{},"表":{"docs":{},"中":{"docs":{},"的":{"docs":{},"任":{"docs":{},"何":{"docs":{},"质":{"docs":{},"数":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"它":{"docs":{},"不":{"docs":{},"会":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"分":{"docs":{},"支":{"docs":{},"。":{"docs":{},"而":{"docs":{},"这":{"docs":{},"里":{"docs":{},"没":{"docs":{},"有":{"docs":{},"其":{"docs":{},"他":{"docs":{},"特":{"docs":{},"别":{"docs":{},"的":{"docs":{},"分":{"docs":{},"支":{"docs":{},"情":{"docs":{},"况":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"e":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"到":{"docs":{},"包":{"docs":{},"含":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}}},")":{"docs":{},"、":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"(":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"、":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"(":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},"、":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"、":{"docs":{},"数":{"docs":{},"组":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},")":{"docs":{},"和":{"docs":{},"字":{"docs":{},"典":{"docs":{},"(":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}},"p":{"docs":{},"i":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}},")":{"docs":{},"或":{"docs":{},"者":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"中":{"docs":{},"使":{"docs":{},"用":{"docs":{},"值":{"docs":{},"绑":{"docs":{},"定":{"docs":{},"来":{"docs":{},"分":{"docs":{},"类":{"docs":{},"下":{"docs":{},"图":{"docs":{},"中":{"docs":{},"的":{"docs":{},"点":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}},"来":{"docs":{},"分":{"docs":{},"类":{"docs":{},"下":{"docs":{},"图":{"docs":{},"中":{"docs":{},"的":{"docs":{},"点":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"a":{"docs":{},"的":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"继":{"docs":{},"而":{"docs":{},"又":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"给":{"docs":{},"了":{"docs":{},"变":{"docs":{},"量":{"docs":{},"b":{"docs":{},"和":{"docs":{},"c":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"产":{"docs":{},"生":{"docs":{},"新":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"一":{"docs":{},"开":{"docs":{},"始":{"docs":{},"先":{"docs":{},"将":{"docs":{},"传":{"docs":{},"入":{"docs":{},"的":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"参":{"docs":{},"数":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"也":{"docs":{},"是":{"docs":{},"唯":{"docs":{},"一":{"docs":{},"在":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"中":{"docs":{},"新":{"docs":{},"引":{"docs":{},"入":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"随":{"docs":{},"后":{"docs":{},"，":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"将":{"docs":{},"任":{"docs":{},"务":{"docs":{},"向":{"docs":{},"上":{"docs":{},"代":{"docs":{},"理":{"docs":{},"给":{"docs":{},"父":{"docs":{},"类":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"只":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"两":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"都":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"这":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"元":{"docs":{},"组":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"仅":{"docs":{},"需":{"docs":{},"要":{"docs":{},"限":{"docs":{},"制":{"docs":{},"一":{"docs":{},"个":{"docs":{},"元":{"docs":{},"组":{"docs":{},"模":{"docs":{},"式":{"docs":{},"中":{"docs":{},"的":{"docs":{},"某":{"docs":{},"几":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"，":{"docs":{},"只":{"docs":{},"需":{"docs":{},"要":{"docs":{},"直":{"docs":{},"接":{"docs":{},"对":{"docs":{},"这":{"docs":{},"几":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"提":{"docs":{},"供":{"docs":{},"类":{"docs":{},"型":{"docs":{},"注":{"docs":{},"释":{"docs":{},"即":{"docs":{},"可":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"在":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}},")":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"元":{"docs":{},"素":{"docs":{},"：":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"是":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"第":{"docs":{},"二":{"docs":{},"个":{"docs":{},"是":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"复":{"docs":{},"合":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"—":{"docs":{},"—":{"docs":{},"也":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"传":{"docs":{},"入":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"然":{"docs":{},"后":{"docs":{},"输":{"docs":{},"出":{"docs":{},"作":{"docs":{},"为":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"函":{"docs":{},"数":{"docs":{},"的":{"docs":{},"输":{"docs":{},"入":{"docs":{},"，":{"docs":{},"然":{"docs":{},"后":{"docs":{},"又":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"如":{"docs":{},"下":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"函":{"docs":{},"数":{"docs":{},"来":{"docs":{},"重":{"docs":{},"写":{"docs":{},"柯":{"docs":{},"里":{"docs":{},"化":{"docs":{},"函":{"docs":{},"数":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"t":{"docs":{},"w":{"docs":{},"o":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"安":{"docs":{},"全":{"docs":{},"和":{"docs":{},"类":{"docs":{},"型":{"docs":{},"推":{"docs":{},"测":{"docs":{},"数":{"docs":{},"值":{"docs":{},"型":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"数":{"docs":{},"值":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"整":{"docs":{},"数":{"docs":{},"转":{"docs":{},"换":{"docs":{},"整":{"docs":{},"数":{"docs":{},"和":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"数":{"docs":{},"转":{"docs":{},"换":{"docs":{},"类":{"docs":{},"型":{"docs":{},"别":{"docs":{},"名":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"值":{"docs":{},"元":{"docs":{},"组":{"docs":{},"可":{"docs":{},"选":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":5}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"够":{"docs":{},"了":{"docs":{},"。":{"docs":{},"这":{"docs":{},"可":{"docs":{},"以":{"docs":{},"提":{"docs":{},"高":{"docs":{},"代":{"docs":{},"码":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"和":{"docs":{},"可":{"docs":{},"复":{"docs":{},"用":{"docs":{},"性":{"docs":{},"。":{"docs":{},"即":{"docs":{},"使":{"docs":{},"是":{"docs":{},"在":{"3":{"2":{"docs":{},"位":{"docs":{},"平":{"docs":{},"台":{"docs":{},"上":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"可":{"docs":{},"以":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"整":{"docs":{},"数":{"docs":{},"范":{"docs":{},"围":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"达":{"docs":{},"到":{"docs":{},"-":{"2":{"1":{"4":{"7":{"4":{"8":{"3":{"6":{"4":{"8":{"docs":{},"~":{"2":{"1":{"4":{"7":{"4":{"8":{"3":{"6":{"4":{"7":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"整":{"docs":{},"型":{"docs":{},"；":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"和":{"docs":{},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"t":{"docs":{},"是":{"docs":{},"浮":{"docs":{},"点":{"docs":{},"型":{"docs":{},"；":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"是":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"型":{"docs":{},"；":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"更":{"docs":{},"大":{"docs":{},"或":{"docs":{},"者":{"docs":{},"更":{"docs":{},"小":{"docs":{},"的":{"docs":{},"数":{"docs":{},"字":{"docs":{},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}},"的":{"docs":{},"合":{"docs":{},"理":{"docs":{},"值":{"docs":{},"。":{"docs":{},"然":{"docs":{},"而":{"docs":{},"，":{"docs":{},"如":{"docs":{},"上":{"docs":{},"所":{"docs":{},"述":{"docs":{},"，":{"docs":{},"当":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"我":{"docs":{},"们":{"docs":{},"不":{"docs":{},"能":{"docs":{},"往":{"docs":{},"其":{"docs":{},"中":{"docs":{},"插":{"docs":{},"入":{"docs":{},"任":{"docs":{},"何":{"docs":{},"不":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"找":{"docs":{},"到":{"docs":{},"一":{"docs":{},"个":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"行":{"docs":{},"星":{"docs":{},"。":{"docs":{},"正":{"docs":{},"因":{"docs":{},"为":{"docs":{},"如":{"docs":{},"此":{"docs":{},"，":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"方":{"docs":{},"法":{"docs":{},"可":{"docs":{},"以":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"，":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"是":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"或":{"docs":{},"“":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"不":{"docs":{},"论":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"多":{"docs":{},"少":{"docs":{},"层":{"docs":{},"链":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"总":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}},"没":{"docs":{},"有":{"docs":{},"足":{"docs":{},"够":{"docs":{},"的":{"docs":{},"位":{"docs":{},"数":{"docs":{},"，":{"docs":{},"即":{"docs":{},"下":{"docs":{},"标":{"docs":{},"越":{"docs":{},"界":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"上":{"docs":{},"述":{"docs":{},"实":{"docs":{},"现":{"docs":{},"的":{"docs":{},"下":{"docs":{},"标":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"0":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"会":{"docs":{},"在":{"docs":{},"数":{"docs":{},"字":{"docs":{},"左":{"docs":{},"边":{"docs":{},"自":{"docs":{},"动":{"docs":{},"补":{"0":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"[":{"docs":{},"]":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"来":{"docs":{},"表":{"docs":{},"达":{"docs":{},"。":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"长":{"docs":{},"度":{"docs":{},"由":{"docs":{},"一":{"docs":{},"个":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}},"或":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"的":{"docs":{},"实":{"docs":{},"际":{"docs":{},"值":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"是":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"，":{"docs":{},"当":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"常":{"docs":{},"量":{"docs":{},"和":{"docs":{},"变":{"docs":{},"量":{"docs":{},"等":{"docs":{},"于":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"u":{"docs":{},"p":{"docs":{},"c":{"docs":{},"a":{"docs":{},"或":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"q":{"docs":{},"r":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524}},";":{"docs":{},"。":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"创":{"docs":{},"建":{"docs":{},"完":{"docs":{},"成":{"docs":{},"之":{"docs":{},"后":{"docs":{},"通":{"docs":{},"过":{"docs":{},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"方":{"docs":{},"式":{"docs":{},"将":{"docs":{},"整":{"docs":{},"型":{"docs":{},"值":{"2":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"到":{"docs":{},"字":{"docs":{},"典":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"索":{"docs":{},"引":{"docs":{},"为":{"docs":{},"b":{"docs":{},"i":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}},"就":{"docs":{},"是":{"docs":{},"用":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"和":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"替":{"docs":{},"代":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"?":{"docs":{},"值":{"docs":{},"，":{"docs":{},"不":{"docs":{},"论":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"多":{"docs":{},"少":{"docs":{},"层":{"docs":{},"链":{"docs":{},"接":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"总":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"将":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}},"，":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"，":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}},"将":{"docs":{},"抽":{"docs":{},"象":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"为":{"docs":{},"具":{"docs":{},"体":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.005272407732864675}},"指":{"docs":{},"定":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"实":{"docs":{},"现":{"docs":{},"，":{"docs":{},"适":{"docs":{},"用":{"docs":{},"的":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"被":{"docs":{},"用":{"docs":{},"作":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"这":{"docs":{},"个":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"只":{"docs":{},"能":{"docs":{},"用":{"docs":{},"于":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"值":{"docs":{},"，":{"docs":{},"不":{"docs":{},"过":{"docs":{},"，":{"docs":{},"其":{"docs":{},"对":{"docs":{},"于":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"现":{"docs":{},"了":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"所":{"docs":{},"有":{"docs":{},"三":{"docs":{},"个":{"docs":{},"要":{"docs":{},"求":{"docs":{},"，":{"docs":{},"在":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"非":{"docs":{},"泛":{"docs":{},"型":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}},"索":{"docs":{},"引":{"docs":{},"值":{"docs":{},"下":{"docs":{},"标":{"docs":{},"可":{"docs":{},"以":{"docs":{},"检":{"docs":{},"索":{"docs":{},"到":{"docs":{},"每":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}},"这":{"docs":{},"一":{"docs":{},"行":{"docs":{},"，":{"docs":{},"一":{"docs":{},"切":{"docs":{},"仍":{"docs":{},"旧":{"docs":{},"可":{"docs":{},"以":{"docs":{},"工":{"docs":{},"作":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"清":{"docs":{},"楚":{"docs":{},"的":{"docs":{},"知":{"docs":{},"道":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{},"。":{"docs":{},"可":{"docs":{},"变":{"docs":{},"长":{"docs":{},"参":{"docs":{},"数":{"docs":{},"被":{"docs":{},"认":{"docs":{},"为":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"基":{"docs":{},"础":{"docs":{},"类":{"docs":{},"型":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"。":{"docs":{},"即":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"就":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"被":{"docs":{},"看":{"docs":{},"做":{"docs":{},"是":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"理":{"docs":{},"解":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}},"引":{"docs":{},"用":{"docs":{},"命":{"docs":{},"名":{"docs":{},"型":{"docs":{},"类":{"docs":{},"型":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"同":{"docs":{},"样":{"docs":{},"，":{"docs":{},"类":{"docs":{},"型":{"docs":{},"标":{"docs":{},"识":{"docs":{},"符":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"均":{"docs":{},"满":{"docs":{},"足":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"）":{"docs":{},"定":{"docs":{},"义":{"docs":{},"一":{"docs":{},"个":{"docs":{},"基":{"docs":{},"类":{"docs":{},"（":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":3.333333333333333}}}}}}}}}}}}}}}}},"）":{"docs":{},"另":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},"）":{"docs":{},"和":{"docs":{},"其":{"docs":{},"它":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"当":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"继":{"docs":{},"承":{"docs":{},"其":{"docs":{},"它":{"docs":{},"类":{"docs":{},"时":{"docs":{},"，":{"docs":{},"继":{"docs":{},"承":{"docs":{},"类":{"docs":{},"叫":{"docs":{},"子":{"docs":{},"类":{"docs":{},"（":{"docs":{},"s":{"docs":{},"u":{"docs":{},"b":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"）":{"docs":{},"，":{"docs":{},"被":{"docs":{},"继":{"docs":{},"承":{"docs":{},"类":{"docs":{},"叫":{"docs":{},"超":{"docs":{},"类":{"docs":{},"（":{"docs":{},"或":{"docs":{},"父":{"docs":{},"类":{"docs":{},"，":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.44243566992014194},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":1.6695402298850572},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}}}}},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}},"函":{"docs":{},"数":{"docs":{},"调":{"docs":{},"用":{"docs":{},"把":{"docs":{},"值":{"docs":{},"为":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}},"i":{"docs":{},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.00927643784786642},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}},"）":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"交":{"docs":{},"换":{"docs":{},"a":{"docs":{},"和":{"docs":{},"b":{"docs":{},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"考":{"docs":{},"[":{"docs":{},"写":{"docs":{},"入":{"docs":{},"读":{"docs":{},"出":{"docs":{},"参":{"docs":{},"数":{"docs":{},"]":{"docs":{},"[":{"1":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"参":{"docs":{},"数":{"docs":{},"类":{"docs":{},"型":{"docs":{},"前":{"docs":{},"加":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"前":{"docs":{},"缀":{"docs":{},"。":{"docs":{},"但":{"docs":{},"是":{"docs":{},"你":{"docs":{},"不":{"docs":{},"可":{"docs":{},"以":{"docs":{},"对":{"docs":{},"可":{"docs":{},"变":{"docs":{},"长":{"docs":{},"参":{"docs":{},"数":{"docs":{},"或":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"。":{"docs":{},"关":{"docs":{},"于":{"docs":{},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"参":{"docs":{},"数":{"docs":{},"的":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"见":{"docs":{},"章":{"docs":{},"节":{"docs":{},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"讨":{"docs":{},"论":{"docs":{},"，":{"docs":{},"参":{"docs":{},"见":{"docs":{},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"参":{"docs":{},"数":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.01054481546572935},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"。":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"v":{"docs":{},"a":{"docs":{},"r":{"docs":{},"­":{"docs":{},"#":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"­":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.2386187455954898}}}}},"中":{"docs":{},"迭":{"docs":{},"代":{"docs":{},"出":{"docs":{},"了":{"docs":{},"b":{"docs":{},"o":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.02188183807439825},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0334075723830735},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.01757469244288225},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.012302284710017574}},"e":{"docs":{},"。":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}},"的":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}},"s":{"docs":{},".":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"这":{"docs":{},"个":{"docs":{},"数":{"docs":{},"组":{"docs":{},"有":{"2":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}}}}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}}}}},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.007029876977152899}}}}}}}}}}}}},"。":{"docs":{},"\"":{"docs":{},"（":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"是":{"0":{"docs":{},"数":{"docs":{},"据":{"docs":{},"项":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}},"docs":{}}}}}}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497}}}},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"空":{"docs":{},"的":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}},"需":{"docs":{},"要":{"docs":{},"真":{"docs":{},"正":{"docs":{},"作":{"docs":{},"为":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997}}}}}}}}}}}},"是":{"docs":{},"如":{"docs":{},"何":{"docs":{},"存":{"docs":{},"储":{"docs":{},"的":{"docs":{},"或":{"docs":{},"何":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"是":{"docs":{},"允":{"docs":{},"许":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"只":{"docs":{},"指":{"docs":{},"定":{"docs":{},"三":{"docs":{},"个":{"docs":{},"任":{"docs":{},"何":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"p":{"docs":{},"u":{"docs":{},"s":{"docs":{},"h":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"该":{"docs":{},"参":{"docs":{},"数":{"docs":{},"必":{"docs":{},"须":{"docs":{},"是":{"docs":{},"t":{"docs":{"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0017574692442882249}}}}}}}}}}}}}}}}}}},"'":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"来":{"docs":{},"作":{"docs":{},"为":{"docs":{},"检":{"docs":{},"查":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}},"o":{"8":{"8":{"5":{"9":{"docs":{},"-":{"1":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"o":{"docs":{},"f":{"docs":{},"x":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}}}}}}}}}}}},"y":{"docs":{},"p":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.009191176470588236}}}}}}},"检":{"docs":{},"验":{"docs":{},"协":{"docs":{},"议":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"a":{"docs":{},"s":{"docs":{},"将":{"docs":{},"协":{"docs":{},"议":{"docs":{},"类":{"docs":{},"型":{"docs":{},"向":{"docs":{},"下":{"docs":{},"转":{"docs":{},"换":{"docs":{},"(":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"­":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"-":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}},"模":{"docs":{},"式":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"这":{"docs":{},"个":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"（":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"）":{"docs":{},"和":{"docs":{},"i":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"右":{"docs":{},"边":{"docs":{},"的":{"docs":{},"指":{"docs":{},"定":{"docs":{},"类":{"docs":{},"型":{"docs":{},"（":{"docs":{},"或":{"docs":{},"者":{"docs":{},"那":{"docs":{},"个":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"）":{"docs":{},"是":{"docs":{},"一":{"docs":{},"致":{"docs":{},"的":{"docs":{},"。":{"docs":{},"i":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"a":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"模":{"docs":{},"式":{"docs":{},"均":{"docs":{},"只":{"docs":{},"出":{"docs":{},"现":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"语":{"docs":{},"句":{"docs":{},"中":{"docs":{},"的":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"标":{"docs":{},"签":{"docs":{},"中":{"docs":{},"。":{"docs":{},"i":{"docs":{},"s":{"docs":{},"模":{"docs":{},"式":{"docs":{},"和":{"docs":{},"a":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.01284796573875803},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.015384615384615385},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.02054794520547945},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},"­":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"­":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.017582417582417582},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.005479452054794521}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.03956043956043956},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.012328767123287671}}}}}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}}}}}}}}}}}}}}}}}}}}}}},"­":{"docs":{},":":{"docs":{},"­":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"-":{"docs":{},"a":{"docs":{},"r":{"docs":{},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"+":{"docs":{},"+":{"docs":{},"的":{"docs":{},"特":{"docs":{},"性":{"docs":{},"，":{"docs":{},"不":{"docs":{},"然":{"docs":{},"推":{"docs":{},"荐":{"docs":{},"你":{"docs":{},"使":{"docs":{},"用":{"docs":{},"+":{"docs":{},"+":{"docs":{},"i":{"docs":{},"和":{"docs":{},"-":{"docs":{},"-":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}},"后":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"返":{"docs":{},"回":{"docs":{},"值":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"只":{"docs":{},"想":{"docs":{},"修":{"docs":{},"改":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}},"，":{"docs":{},"i":{"docs":{},"+":{"docs":{},"+":{"docs":{},"，":{"docs":{},"-":{"docs":{},"-":{"docs":{},"i":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"就":{"docs":{},"会":{"docs":{},"加":{"1":{"docs":{},"。":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"，":{"docs":{},"+":{"docs":{},"+":{"docs":{},"i":{"docs":{},"是":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}},"docs":{}}}}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}},"b":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"和":{"docs":{},"i":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"声":{"docs":{},"明":{"docs":{},"；":{"docs":{},"i":{"docs":{},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"特":{"docs":{},"性":{"docs":{},"用":{"docs":{},"于":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"声":{"docs":{},"明":{"docs":{},"；":{"docs":{},"i":{"docs":{},"b":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}}}}}}},"o":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.00929368029739777},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.09302325581395349},"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.019469026548672566},"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.02040816326530612},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0022271714922048997},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}},"中":{"docs":{},"表":{"docs":{},"示":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"，":{"docs":{},"比":{"docs":{},"如":{"docs":{},"，":{"docs":{},"非":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"类":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"类":{"docs":{},"和":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"方":{"docs":{},"法":{"docs":{},"（":{"docs":{},"包":{"docs":{},"含":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"，":{"docs":{},"析":{"docs":{},"构":{"docs":{},"器":{"docs":{},"，":{"docs":{},"以":{"docs":{},"下":{"docs":{},"下":{"docs":{},"标":{"docs":{},"。":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"告":{"docs":{},"诉":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"该":{"docs":{},"声":{"docs":{},"明":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"-":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"元":{"docs":{},"素":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"因":{"docs":{},"为":{"docs":{},"向":{"docs":{},"下":{"docs":{},"转":{"docs":{},"型":{"docs":{},"而":{"docs":{},"改":{"docs":{},"变":{"docs":{},"，":{"docs":{},"当":{"docs":{},"它":{"docs":{},"们":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"时":{"docs":{},"只":{"docs":{},"被":{"docs":{},"视":{"docs":{},"为":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"只":{"docs":{},"有":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"元":{"docs":{},"素":{"docs":{},"是":{"docs":{},"否":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"，":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"属":{"docs":{},"性":{"docs":{},"就":{"docs":{},"隐":{"docs":{},"性":{"docs":{},"地":{"docs":{},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"；":{"docs":{},"没":{"docs":{},"有":{"docs":{},"必":{"docs":{},"要":{"docs":{},"再":{"docs":{},"明":{"docs":{},"确":{"docs":{},"地":{"docs":{},"使":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.021052631578947368}},"前":{"docs":{},"缀":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"中":{"docs":{},"生":{"docs":{},"效":{"docs":{},"。":{"docs":{},"且":{"docs":{},"@":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"协":{"docs":{},"议":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"表":{"docs":{},"示":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"的":{"docs":{},"代":{"docs":{},"码":{"docs":{},"，":{"docs":{},"此":{"docs":{},"外":{"docs":{},"，":{"docs":{},"@":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"型":{"docs":{},"协":{"docs":{},"议":{"docs":{},"只":{"docs":{},"对":{"docs":{},"类":{"docs":{},"有":{"docs":{},"效":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"只":{"docs":{},"能":{"docs":{},"在":{"docs":{},"类":{"docs":{},"中":{"docs":{},"检":{"docs":{},"查":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"。":{"docs":{},"详":{"docs":{},"情":{"docs":{},"查":{"docs":{},"看":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}},"特":{"docs":{},"性":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"一":{"docs":{},"个":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"特":{"docs":{},"性":{"docs":{},"就":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"应":{"docs":{},"用":{"docs":{},"到":{"docs":{},"该":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"因":{"docs":{},"此":{"docs":{},"无":{"docs":{},"需":{"docs":{},"显":{"docs":{},"式":{"docs":{},"地":{"docs":{},"用":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"_":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"t":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"一":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"它":{"docs":{},"也":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"应":{"docs":{},"用":{"docs":{},"于":{"docs":{},"那":{"docs":{},"个":{"docs":{},"类":{"docs":{},"或":{"docs":{},"协":{"docs":{},"议":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"地":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"子":{"docs":{},"类":{"docs":{},"添":{"docs":{},"加":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"。":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"不":{"docs":{},"能":{"docs":{},"继":{"docs":{},"承":{"docs":{},"自":{"docs":{},"没":{"docs":{},"有":{"docs":{},"标":{"docs":{},"记":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"参":{"docs":{},"数":{"docs":{},"，":{"docs":{},"由":{"docs":{},"标":{"docs":{},"记":{"docs":{},"符":{"docs":{},"组":{"docs":{},"成":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"想":{"docs":{},"把":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"所":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"的":{"docs":{},"实":{"docs":{},"体":{"docs":{},"以":{"docs":{},"一":{"docs":{},"个":{"docs":{},"不":{"docs":{},"同":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"特":{"docs":{},"性":{"docs":{},"参":{"docs":{},"数":{"docs":{},"。":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"参":{"docs":{},"数":{"docs":{},"来":{"docs":{},"命":{"docs":{},"名":{"docs":{},"类":{"docs":{},"，":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"，":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"，":{"docs":{},"以":{"docs":{},"及":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"器":{"docs":{},"。":{"docs":{},"下":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"把":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"中":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"暴":{"docs":{},"露":{"docs":{},"给":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"，":{"docs":{},"名":{"docs":{},"字":{"docs":{},"是":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":3.3369963369963367},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}},"e":{"docs":{},"r":{"docs":{},"）":{"docs":{},"，":{"docs":{},"这":{"docs":{},"样":{"docs":{},"一":{"docs":{},"来":{"docs":{},"，":{"docs":{},"当":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"改":{"docs":{},"变":{"docs":{},"时":{"docs":{},"，":{"docs":{},"类":{"docs":{},"就":{"docs":{},"会":{"docs":{},"被":{"docs":{},"通":{"docs":{},"知":{"docs":{},"到":{"docs":{},"。":{"docs":{},"可":{"docs":{},"以":{"docs":{},"为":{"docs":{},"任":{"docs":{},"何":{"docs":{},"属":{"docs":{},"性":{"docs":{},"添":{"docs":{},"加":{"docs":{},"属":{"docs":{},"性":{"docs":{},"观":{"docs":{},"察":{"docs":{},"器":{"docs":{},"，":{"docs":{},"无":{"docs":{},"论":{"docs":{},"它":{"docs":{},"原":{"docs":{},"本":{"docs":{},"被":{"docs":{},"定":{"docs":{},"义":{"docs":{},"为":{"docs":{},"存":{"docs":{},"储":{"docs":{},"型":{"docs":{},"属":{"docs":{},"性":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.046511627906976744},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}},"c":{"docs":{},"c":{"docs":{},"u":{"docs":{},"p":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"[":{"docs":{},"\"":{"docs":{},"j":{"docs":{},"a":{"docs":{},"y":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}},"-":{"docs":{},"d":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"a":{"docs":{},"l":{"docs":{},"-":{"docs":{},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.01098901098901099},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"t":{"docs":{"chapter3/01_About_the_Language_Reference.html#gitbook_6519":{"ref":"chapter3/01_About_the_Language_Reference.html#gitbook_6519","tf":0.037037037037037035},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.008356545961002786},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.034261241970021415},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.04395604395604396},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.011494252873563218},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.10890410958904109},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.058823529411764705}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.017699115044247787},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":5.009554140127388},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.011135857461024499},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.005928853754940711},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"e":{"docs":{},"改":{"docs":{},"成":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"，":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"会":{"docs":{},"是":{"docs":{},"什":{"docs":{},"么":{"docs":{},"？":{"docs":{},"添":{"docs":{},"加":{"docs":{},"一":{"docs":{},"个":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"语":{"docs":{},"句":{"docs":{},"，":{"docs":{},"当":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"时":{"docs":{},"给":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}},"e":{"docs":{},"?":{"docs":{},".":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}},"）":{"docs":{},"。":{"docs":{},"把":{"docs":{},"想":{"docs":{},"要":{"docs":{},"用":{"docs":{},"作":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"后":{"docs":{},"面":{"docs":{},"的":{"docs":{},"问":{"docs":{},"号":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},"）":{"docs":{},"改":{"docs":{},"成":{"docs":{},"感":{"docs":{},"叹":{"docs":{},"号":{"docs":{},"（":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"特":{"docs":{},"性":{"docs":{},"修":{"docs":{},"饰":{"docs":{},"那":{"docs":{},"些":{"docs":{},"标":{"docs":{},"记":{"docs":{},"了":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"特":{"docs":{},"性":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"因":{"docs":{},"此":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"类":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"a":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"&":{"docs":{},"l":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"&":{"docs":{},"g":{"docs":{},"t":{"docs":{},";":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"，":{"docs":{},"有":{"docs":{},"两":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"，":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"和":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"t":{"docs":{},")":{"docs":{},"，":{"docs":{},"又":{"docs":{},"来":{"docs":{},"代":{"docs":{},"表":{"docs":{},"可":{"docs":{},"能":{"docs":{},"出":{"docs":{},"现":{"docs":{},"或":{"docs":{},"可":{"docs":{},"能":{"docs":{},"不":{"docs":{},"出":{"docs":{},"现":{"docs":{},"的":{"docs":{},"值":{"docs":{},"。":{"docs":{},"任":{"docs":{},"意":{"docs":{},"类":{"docs":{},"型":{"docs":{},"都":{"docs":{},"可":{"docs":{},"以":{"docs":{},"被":{"docs":{},"显":{"docs":{},"式":{"docs":{},"的":{"docs":{},"声":{"docs":{},"明":{"docs":{},"（":{"docs":{},"或":{"docs":{},"隐":{"docs":{},"式":{"docs":{},"的":{"docs":{},"转":{"docs":{},"换":{"docs":{},"）":{"docs":{},"为":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"当":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"可":{"docs":{},"选":{"docs":{},"类":{"docs":{},"型":{"docs":{},"时":{"docs":{},"，":{"docs":{},"确":{"docs":{},"保":{"docs":{},"使":{"docs":{},"用":{"docs":{},"括":{"docs":{},"号":{"docs":{},"给":{"docs":{},"?":{"docs":{},"提":{"docs":{},"供":{"docs":{},"合":{"docs":{},"适":{"docs":{},"的":{"docs":{},"作":{"docs":{},"用":{"docs":{},"范":{"docs":{},"围":{"docs":{},"。":{"docs":{},"比":{"docs":{},"如":{"docs":{},"说":{"docs":{},"，":{"docs":{},"声":{"docs":{},"明":{"docs":{},"一":{"docs":{},"个":{"docs":{},"整":{"docs":{},"型":{"docs":{},"的":{"docs":{},"可":{"docs":{},"选":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"应":{"docs":{},"写":{"docs":{},"作":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"[":{"docs":{},"]":{"docs":{},")":{"docs":{},"?":{"docs":{},"，":{"docs":{},"写":{"docs":{},"成":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"-":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.005571030640668524},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"-":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}}}}}}}}}}},"<":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"g":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.013927576601671309}}}}}}},"属":{"docs":{},"性":{"docs":{},"标":{"docs":{},"注":{"docs":{},"这":{"docs":{},"些":{"docs":{},"协":{"docs":{},"议":{"docs":{},"成":{"docs":{},"员":{"docs":{},"声":{"docs":{},"明":{"docs":{},"以":{"docs":{},"指":{"docs":{},"定":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"一":{"docs":{},"致":{"docs":{},"性":{"docs":{},"类":{"docs":{},"型":{"docs":{},"实":{"docs":{},"现":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"的":{"docs":{},"。":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"属":{"docs":{},"性":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"使":{"docs":{},"用":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"c":{"docs":{},"属":{"docs":{},"性":{"docs":{},"标":{"docs":{},"记":{"docs":{},"过":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"这":{"docs":{},"样":{"docs":{},"的":{"docs":{},"结":{"docs":{},"果":{"docs":{},"就":{"docs":{},"是":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"类":{"docs":{},"类":{"docs":{},"型":{"docs":{},"可":{"docs":{},"以":{"docs":{},"采":{"docs":{},"用":{"docs":{},"并":{"docs":{},"符":{"docs":{},"合":{"docs":{},"包":{"docs":{},"含":{"docs":{},"可":{"docs":{},"选":{"docs":{},"成":{"docs":{},"员":{"docs":{},"要":{"docs":{},"求":{"docs":{},"的":{"docs":{},"协":{"docs":{},"议":{"docs":{},"。":{"docs":{},"更":{"docs":{},"多":{"docs":{},"关":{"docs":{},"于":{"docs":{},"如":{"docs":{},"何":{"docs":{},"使":{"docs":{},"用":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"­":{"docs":{},"#":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"­":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"-":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"-":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"­":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"-":{"docs":{},"b":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":2.0097560975609756},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0074211502782931356},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.015810276679841896},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.016059957173447537},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.015384615384615385},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.009589041095890411}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"）":{"docs":{},"比":{"docs":{},"较":{"docs":{},"运":{"docs":{},"算":{"docs":{},"三":{"docs":{},"元":{"docs":{},"条":{"docs":{},"件":{"docs":{},"运":{"docs":{},"算":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":2}}}}}}}}}}}}}}}}}}}},"主":{"docs":{},"要":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"（":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}},"的":{"docs":{},"更":{"docs":{},"多":{"docs":{},"信":{"docs":{},"息":{"docs":{},"，":{"docs":{},"请":{"docs":{},"参":{"docs":{},"见":{"docs":{},"：":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}},"）":{"docs":{},"三":{"docs":{},"元":{"docs":{},"条":{"docs":{},"件":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}},"类":{"docs":{},"型":{"docs":{},"转":{"docs":{},"换":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.3448275862068966}}}}}}}}}}}}}}}}}}},"、":{"docs":{},"后":{"docs":{},"缀":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}},"或":{"docs":{},"二":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"（":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}},")":{"docs":{},"是":{"docs":{},"一":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"，":{"docs":{},"例":{"docs":{},"如":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"+":{"docs":{},"+":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}},"-":{"docs":{},"d":{"docs":{},"e":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}}}},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"­":{"docs":{},"{":{"docs":{},"­":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"-":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"-":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"和":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"之":{"docs":{},"间":{"docs":{},"添":{"docs":{},"加":{"docs":{},"上":{"docs":{},"下":{"docs":{},"文":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"，":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"或":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"来":{"docs":{},"指":{"docs":{},"定":{"docs":{},"。":{"docs":{},"每":{"docs":{},"种":{"docs":{},"形":{"docs":{},"式":{"docs":{},"中":{"docs":{},"，":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"只":{"docs":{},"能":{"docs":{},"包":{"docs":{},"含":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}},"e":{"docs":{},"和":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"s":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"会":{"docs":{},"被":{"docs":{},"推":{"docs":{},"测":{"docs":{},"为":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"们":{"docs":{},"的":{"docs":{},"初":{"docs":{},"值":{"docs":{},"是":{"docs":{},"布":{"docs":{},"尔":{"docs":{},"字":{"docs":{},"面":{"docs":{},"量":{"docs":{},"。":{"docs":{},"就":{"docs":{},"像":{"docs":{},"之":{"docs":{},"前":{"docs":{},"提":{"docs":{},"到":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"和":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"一":{"docs":{},"样":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"你":{"docs":{},"创":{"docs":{},"建":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"给":{"docs":{},"它":{"docs":{},"们":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"f":{"docs":{},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"，":{"docs":{},"那":{"docs":{},"你":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"者":{"docs":{},"变":{"docs":{},"量":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.0035149384885764497},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.022988505747126436}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889}}},"x":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.008888888888888889}}}},"的":{"docs":{},"x":{"docs":{},"和":{"docs":{},"i":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}},"x":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.02564102564102564},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0032119914346895075},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"标":{"docs":{},"记":{"docs":{},"—":{"docs":{},"—":{"docs":{},"如":{"docs":{},"果":{"docs":{},"没":{"docs":{},"有":{"docs":{},"添":{"docs":{},"加":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"就":{"docs":{},"重":{"docs":{},"写":{"docs":{},"父":{"docs":{},"类":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"话":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"会":{"docs":{},"报":{"docs":{},"错":{"docs":{},"。":{"docs":{},"编":{"docs":{},"译":{"docs":{},"器":{"docs":{},"同":{"docs":{},"样":{"docs":{},"会":{"docs":{},"检":{"docs":{},"测":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"。":{"docs":{},"这":{"docs":{},"么":{"docs":{},"做":{"docs":{},"，":{"docs":{},"你":{"docs":{},"就":{"docs":{},"表":{"docs":{},"明":{"docs":{},"了":{"docs":{},"你":{"docs":{},"是":{"docs":{},"想":{"docs":{},"提":{"docs":{},"供":{"docs":{},"一":{"docs":{},"个":{"docs":{},"重":{"docs":{},"写":{"docs":{},"版":{"docs":{},"本":{"docs":{},"，":{"docs":{},"而":{"docs":{},"非":{"docs":{},"错":{"docs":{},"误":{"docs":{},"地":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"相":{"docs":{},"同":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"。":{"docs":{},"意":{"docs":{},"外":{"docs":{},"的":{"docs":{},"重":{"docs":{},"写":{"docs":{},"行":{"docs":{},"为":{"docs":{},"可":{"docs":{},"能":{"docs":{},"会":{"docs":{},"导":{"docs":{},"致":{"docs":{},"不":{"docs":{},"可":{"docs":{},"预":{"docs":{},"知":{"docs":{},"的":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"任":{"docs":{},"何":{"docs":{},"缺":{"docs":{},"少":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.003663003663003663}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"作":{"docs":{},"为":{"docs":{},"函":{"docs":{},"数":{"docs":{},"声":{"docs":{},"明":{"docs":{},"头":{"docs":{},"。":{"docs":{},"不":{"docs":{},"用":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"重":{"docs":{},"写":{"docs":{},"的":{"docs":{},"方":{"docs":{},"法":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"了":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.004940711462450593}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}}}}}},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.007653061224489796}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653}}}}}}}}}}}}}}},"k":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717},"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0017699115044247787}}}}}}}},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}},"b":{"docs":{},"a":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}},"枚":{"docs":{},"举":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"了":{"docs":{},"t":{"docs":{},"o":{"docs":{},"g":{"docs":{},"g":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"协":{"docs":{},"议":{"docs":{},"，":{"docs":{},"o":{"docs":{},"n":{"docs":{},"，":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.01},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.011940298507462687},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.0055147058823529415},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.031496062992125984},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.006016847172081829}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}},"l":{"docs":{},"d":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0044444444444444444}}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"a":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0038095238095238095}}}}}}},"d":{"docs":{},"y":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}}}},"r":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter1/01_swift.html#gitbook_6466":{"ref":"chapter1/01_swift.html#gitbook_6466","tf":0.023255813953488372},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0048484848484848485},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.5615257048092869},"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.0103359173126615},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"1":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.011428571428571429}}},"2":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.005714285714285714}}},"3":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619}}},"docs":{},"）":{"docs":{},"和":{"docs":{},"无":{"docs":{},"主":{"docs":{},"引":{"docs":{},"用":{"docs":{},"（":{"docs":{},"u":{"docs":{},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"n":{"docs":{"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0037105751391465678}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"n":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}},"<":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},">":{"docs":{},"(":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}}},"e":{"docs":{},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}},"e":{"docs":{},":":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}},"docs":{}}},"docs":{}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.005747126436781609}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.2894317578332448}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}}}}},"s":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0036363636363636364},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"u":{"docs":{},"n":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048}}},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}},"e":{"docs":{},"声":{"docs":{},"明":{"docs":{},"为":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"?":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"或":{"docs":{},"者":{"docs":{},"说":{"docs":{},"是":{"docs":{},"可":{"docs":{},"选":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"类":{"docs":{},"型":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.020671834625323}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},"或":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"显":{"docs":{},"示":{"docs":{},"器":{"docs":{},"的":{"docs":{},"像":{"docs":{},"素":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},"和":{"docs":{},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"的":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"储":{"docs":{},"存":{"docs":{},"属":{"docs":{},"性":{"docs":{},"是":{"docs":{},"捆":{"docs":{},"绑":{"docs":{},"和":{"docs":{},"储":{"docs":{},"存":{"docs":{},"在":{"docs":{},"类":{"docs":{},"或":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"中":{"docs":{},"的":{"docs":{},"常":{"docs":{},"量":{"docs":{},"或":{"docs":{},"变":{"docs":{},"量":{"docs":{},"。":{"docs":{},"当":{"docs":{},"这":{"docs":{},"两":{"docs":{},"个":{"docs":{},"属":{"docs":{},"性":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"整":{"docs":{},"数":{"0":{"docs":{},"的":{"docs":{},"时":{"docs":{},"候":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"会":{"docs":{},"被":{"docs":{},"推":{"docs":{},"断":{"docs":{},"为":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"和":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"类":{"docs":{},"的":{"docs":{},"定":{"docs":{},"义":{"docs":{},"仅":{"docs":{},"描":{"docs":{},"述":{"docs":{},"了":{"docs":{},"什":{"docs":{},"么":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"和":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"。":{"docs":{},"它":{"docs":{},"们":{"docs":{},"并":{"docs":{},"没":{"docs":{},"有":{"docs":{},"描":{"docs":{},"述":{"docs":{},"一":{"docs":{},"个":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"分":{"docs":{},"辨":{"docs":{},"率":{"docs":{},"（":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"）":{"docs":{},"或":{"docs":{},"者":{"docs":{},"视":{"docs":{},"频":{"docs":{},"模":{"docs":{},"式":{"docs":{},"（":{"docs":{},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"o":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"6":{"4":{"0":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"e":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}},"将":{"docs":{},"计":{"docs":{},"数":{"docs":{},"器":{"docs":{},"重":{"docs":{},"置":{"docs":{},"为":{"0":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265}}},"docs":{}}}}}}}}},"r":{"docs":{},"v":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.041401273885350316}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"?":{"docs":{},"属":{"docs":{},"性":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"存":{"docs":{},"在":{"docs":{},"则":{"docs":{},"取":{"docs":{},"回":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"中":{"docs":{},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}},"具":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}},"存":{"docs":{},"储":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"实":{"docs":{},"例":{"docs":{},"的":{"docs":{},"数":{"docs":{},"组":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"不":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"固":{"docs":{},"定":{"docs":{},"的":{"docs":{},"存":{"docs":{},"储":{"docs":{},"值":{"docs":{},"，":{"docs":{},"而":{"docs":{},"是":{"docs":{},"通":{"docs":{},"过":{"docs":{},"计":{"docs":{},"算":{"docs":{},"而":{"docs":{},"来":{"docs":{},"的":{"docs":{},"。":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"是":{"docs":{},"由":{"docs":{},"返":{"docs":{},"回":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"自":{"docs":{},"判":{"docs":{},"断":{"docs":{},"属":{"docs":{},"性":{"docs":{},"叫":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"（":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"?":{"docs":{},"）":{"docs":{},"。":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"实":{"docs":{},"例":{"docs":{},"给":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"，":{"docs":{},"且":{"docs":{},"在":{"docs":{},"他":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"或":{"docs":{},"多":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"你":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"通":{"docs":{},"过":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"在":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"属":{"docs":{},"性":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"属":{"docs":{},"性":{"docs":{},"值":{"docs":{},"，":{"docs":{},"将":{"docs":{},"会":{"docs":{},"引":{"docs":{},"发":{"docs":{},"运":{"docs":{},"行":{"docs":{},"时":{"docs":{},"错":{"docs":{},"误":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"这":{"docs":{},"时":{"docs":{},"没":{"docs":{},"有":{"docs":{},"可":{"docs":{},"以":{"docs":{},"供":{"docs":{},"解":{"docs":{},"析":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"方":{"docs":{},"法":{"docs":{},"会":{"docs":{},"打":{"docs":{},"印":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"中":{"docs":{},"定":{"docs":{},"义":{"docs":{},"的":{"docs":{},"子":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"来":{"docs":{},"获":{"docs":{},"取":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"数":{"docs":{},"组":{"docs":{},"中":{"docs":{},"第":{"docs":{},"一":{"docs":{},"个":{"docs":{},"房":{"docs":{},"间":{"docs":{},"的":{"docs":{},"名":{"docs":{},"字":{"docs":{},"。":{"docs":{},"因":{"docs":{},"为":{"docs":{},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"现":{"docs":{},"在":{"docs":{},"是":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.03428571428571429},"chapter2/13_Inheritance.html#gitbook_6471":{"ref":"chapter2/13_Inheritance.html#gitbook_6471","tf":0.014652014652014652},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.9762931642001409},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.588391376451078},"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.01020408163265306},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.021621621621621623},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.007352941176470588},"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.007619047619047619},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.01910828025477707},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.031496062992125984},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.040229885057471264},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.012033694344163659},"chapter2/22_Generics.html#gitbook_6512":{"ref":"chapter2/22_Generics.html#gitbook_6512","tf":0.03163444639718805},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.012987012987012988},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.016713091922005572},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.010706638115631691},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.015267175572519083},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":1.1279178338001867}},"f":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}},"）":{"docs":{},"\\":{"docs":{},"r":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"或":{"docs":{},"换":{"docs":{},"行":{"docs":{},"符":{"docs":{},"（":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}},"（":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"docs":{}},"docs":{}},"docs":{}}}}},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301},"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0056022408963585435}}}}}}},"时":{"docs":{},"，":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"是":{"docs":{},"将":{"docs":{},"控":{"docs":{},"制":{"docs":{},"权":{"docs":{},"从":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"传":{"docs":{},"递":{"docs":{},"给":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"值":{"docs":{},"。":{"docs":{},"（":{"docs":{},"这":{"docs":{},"就":{"docs":{},"是":{"docs":{},"说":{"docs":{},"，":{"docs":{},"该":{"docs":{},"函":{"docs":{},"数":{"docs":{},"或":{"docs":{},"方":{"docs":{},"法":{"docs":{},"的":{"docs":{},"返":{"docs":{},"回":{"docs":{},"类":{"docs":{},"型":{"docs":{},"为":{"docs":{},"v":{"docs":{},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"语":{"docs":{},"句":{"docs":{},"后":{"docs":{},"面":{"docs":{},"带":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"时":{"docs":{},"，":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"的":{"docs":{},"值":{"docs":{},"将":{"docs":{},"会":{"docs":{},"返":{"docs":{},"回":{"docs":{},"给":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"。":{"docs":{},"如":{"docs":{},"果":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"值":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"与":{"docs":{},"调":{"docs":{},"用":{"docs":{},"者":{"docs":{},"期":{"docs":{},"望":{"docs":{},"的":{"docs":{},"类":{"docs":{},"型":{"docs":{},"不":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"，":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"只":{"docs":{},"写":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{},"这":{"docs":{},"个":{"docs":{},"关":{"docs":{},"键":{"docs":{},"词":{"docs":{},"，":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"在":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"chapter3/10_Statements.html#gitbook_6535":{"ref":"chapter3/10_Statements.html#gitbook_6535","tf":0.0028011204481792717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.03503184713375796}}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}},"d":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"方":{"docs":{},"法":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"避":{"docs":{},"免":{"docs":{},"我":{"docs":{},"们":{"docs":{},"需":{"docs":{},"要":{"docs":{},"获":{"docs":{},"取":{"docs":{},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"方":{"docs":{},"法":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"来":{"docs":{},"在":{"docs":{},"字":{"docs":{},"典":{"docs":{},"中":{"docs":{},"移":{"docs":{},"除":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"方":{"docs":{},"法":{"docs":{},"在":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"存":{"docs":{},"在":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"会":{"docs":{},"移":{"docs":{},"除":{"docs":{},"该":{"docs":{},"键":{"docs":{},"值":{"docs":{},"对":{"docs":{},"并":{"docs":{},"且":{"docs":{},"返":{"docs":{},"回":{"docs":{},"被":{"docs":{},"移":{"docs":{},"除":{"docs":{},"的":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"或":{"docs":{},"者":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"值":{"docs":{},"的":{"docs":{},"情":{"docs":{},"况":{"docs":{},"下":{"docs":{},"返":{"docs":{},"回":{"docs":{},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.00516795865633075}},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"了":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},"，":{"docs":{},"实":{"docs":{},"际":{"docs":{},"上":{"docs":{},"它":{"docs":{},"被":{"docs":{},"赋":{"docs":{},"予":{"docs":{},"的":{"docs":{},"是":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{},"的":{"docs":{},"一":{"docs":{},"个":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"过":{"docs":{},"程":{"docs":{},"结":{"docs":{},"束":{"docs":{},"后":{"docs":{},"再":{"docs":{},"修":{"docs":{},"改":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"的":{"docs":{},"值":{"docs":{},"并":{"docs":{},"不":{"docs":{},"影":{"docs":{},"响":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"所":{"docs":{},"储":{"docs":{},"存":{"docs":{},"的":{"docs":{},"原":{"docs":{},"始":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.002857142857142857}}}}},"d":{"docs":{},"-":{"docs":{},"o":{"docs":{},"n":{"docs":{},"l":{"docs":{},"i":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.026865671641791045}}}}}},"c":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.006666666666666667},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.011494252873563218}},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}},"也":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"。":{"docs":{},"一":{"docs":{},"个":{"docs":{},"矩":{"docs":{},"形":{"docs":{},"的":{"docs":{},"中":{"docs":{},"心":{"docs":{},"点":{"docs":{},"可":{"docs":{},"以":{"docs":{},"从":{"docs":{},"原":{"docs":{},"点":{"docs":{},"和":{"docs":{},"尺":{"docs":{},"寸":{"docs":{},"来":{"docs":{},"算":{"docs":{},"出":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"不":{"docs":{},"需":{"docs":{},"要":{"docs":{},"将":{"docs":{},"它":{"docs":{},"以":{"docs":{},"显":{"docs":{},"式":{"docs":{},"声":{"docs":{},"明":{"docs":{},"的":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"来":{"docs":{},"保":{"docs":{},"存":{"docs":{},"。":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"的":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"创":{"docs":{},"建":{"docs":{},"实":{"docs":{},"例":{"docs":{},"-":{"docs":{},"-":{"docs":{},"使":{"docs":{},"用":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"0":{"docs":{},"值":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"；":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"实":{"docs":{},"例":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"；":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"定":{"docs":{},"的":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"来":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"。":{"docs":{},"在":{"docs":{},"下":{"docs":{},"面":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"，":{"docs":{},"在":{"docs":{},"功":{"docs":{},"能":{"docs":{},"上":{"docs":{},"跟":{"docs":{},"没":{"docs":{},"有":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"时":{"docs":{},"自":{"docs":{},"动":{"docs":{},"获":{"docs":{},"得":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"空":{"docs":{},"函":{"docs":{},"数":{"docs":{},"，":{"docs":{},"使":{"docs":{},"用":{"docs":{},"一":{"docs":{},"对":{"docs":{},"大":{"docs":{},"括":{"docs":{},"号":{"docs":{},"{":{"docs":{},"}":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"，":{"docs":{},"它":{"docs":{},"没":{"docs":{},"有":{"docs":{},"执":{"docs":{},"行":{"docs":{},"任":{"docs":{},"何":{"docs":{},"定":{"docs":{},"制":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"过":{"docs":{},"程":{"docs":{},"。":{"docs":{},"调":{"docs":{},"用":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"将":{"docs":{},"返":{"docs":{},"回":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"它":{"docs":{},"的":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"都":{"docs":{},"使":{"docs":{},"用":{"docs":{},"定":{"docs":{},"义":{"docs":{},"时":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"x":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{},")":{"docs":{},"稍":{"docs":{},"微":{"docs":{},"复":{"docs":{},"杂":{"docs":{},"一":{"docs":{},"点":{"docs":{},"。":{"docs":{},"它":{"docs":{},"先":{"docs":{},"通":{"docs":{},"过":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"和":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"的":{"docs":{},"值":{"docs":{},"计":{"docs":{},"算":{"docs":{},"出":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"的":{"docs":{},"坐":{"docs":{},"标":{"docs":{},"。":{"docs":{},"然":{"docs":{},"后":{"docs":{},"再":{"docs":{},"调":{"docs":{},"用":{"docs":{},"（":{"docs":{},"或":{"docs":{},"代":{"docs":{},"理":{"docs":{},"给":{"docs":{},"）":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{},")":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"来":{"docs":{},"将":{"docs":{},"新":{"docs":{},"的":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},":":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},":":{"docs":{},")":{"docs":{},"，":{"docs":{},"在":{"docs":{},"功":{"docs":{},"能":{"docs":{},"上":{"docs":{},"跟":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"在":{"docs":{},"没":{"docs":{},"有":{"docs":{},"自":{"docs":{},"定":{"docs":{},"义":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"时":{"docs":{},"获":{"docs":{},"得":{"docs":{},"的":{"docs":{},"逐":{"docs":{},"一":{"docs":{},"成":{"docs":{},"员":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"只":{"docs":{},"是":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"将":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"和":{"docs":{},"s":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"用":{"docs":{},"来":{"docs":{},"展":{"docs":{},"现":{"docs":{},"几":{"docs":{},"何":{"docs":{},"矩":{"docs":{},"形":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"需":{"docs":{},"要":{"docs":{},"两":{"docs":{},"个":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"的":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"各":{"docs":{},"自":{"docs":{},"为":{"docs":{},"其":{"docs":{},"所":{"docs":{},"有":{"docs":{},"的":{"docs":{},"属":{"docs":{},"性":{"docs":{},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"例":{"docs":{},"子":{"docs":{},"同":{"docs":{},"时":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"两":{"docs":{},"个":{"docs":{},"辅":{"docs":{},"助":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"和":{"docs":{},"p":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"把":{"0":{"docs":{},".":{"0":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"提":{"docs":{},"供":{"docs":{},"了":{"docs":{},"其":{"docs":{},"所":{"docs":{},"有":{"docs":{},"属":{"docs":{},"性":{"docs":{},"的":{"docs":{},"默":{"docs":{},"认":{"docs":{},"值":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"正":{"docs":{},"如":{"docs":{},"默":{"docs":{},"认":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"中":{"docs":{},"描":{"docs":{},"述":{"docs":{},"的":{"docs":{},"，":{"docs":{},"它":{"docs":{},"可":{"docs":{},"以":{"docs":{},"自":{"docs":{},"动":{"docs":{},"接":{"docs":{},"受":{"docs":{},"一":{"docs":{},"个":{"docs":{},"默":{"docs":{},"认":{"docs":{},"的":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"成":{"docs":{},"员":{"docs":{},"级":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"。":{"docs":{},"这":{"docs":{},"些":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"可":{"docs":{},"以":{"docs":{},"用":{"docs":{},"于":{"docs":{},"构":{"docs":{},"造":{"docs":{},"新":{"docs":{},"的":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.012867647058823529}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}},"也":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}},"的":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}},"子":{"docs":{},"类":{"docs":{},"，":{"docs":{},"叫":{"docs":{},"做":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"p":{"docs":{},"p":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}},"父":{"docs":{},"类":{"docs":{},"是":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"，":{"docs":{},"它":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"便":{"docs":{},"利":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"因":{"docs":{},"此":{"docs":{},"也":{"docs":{},"被":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"继":{"docs":{},"承":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"继":{"docs":{},"承":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},"函":{"docs":{},"数":{"docs":{},"版":{"docs":{},"本":{"docs":{},"跟":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"提":{"docs":{},"供":{"docs":{},"的":{"docs":{},"版":{"docs":{},"本":{"docs":{},"是":{"docs":{},"一":{"docs":{},"样":{"docs":{},"的":{"docs":{},"，":{"docs":{},"除":{"docs":{},"了":{"docs":{},"它":{"docs":{},"是":{"docs":{},"将":{"docs":{},"任":{"docs":{},"务":{"docs":{},"代":{"docs":{},"理":{"docs":{},"给":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"p":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"版":{"docs":{},"本":{"docs":{},"的":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"类":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"指":{"docs":{},"定":{"docs":{},"构":{"docs":{},"造":{"docs":{},"器":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/15_Deinitialization.html#gitbook_6498":{"ref":"chapter2/15_Deinitialization.html#gitbook_6498","tf":0.0064516129032258064}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635},"chapter3/06_Attributes.html#gitbook_6517":{"ref":"chapter3/06_Attributes.html#gitbook_6517","tf":0.010526315789473684},"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.022900763358778626},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"r":{"docs":{},"e":{"docs":{},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531":{"ref":"chapter3/08_Generic_Parameters_and_Arguments.html#gitbook_6531","tf":0.007633587786259542}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}},"n":{"docs":{},"k":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.005714285714285714},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.047244094488188976}},".":{"docs":{},"a":{"docs":{},"c":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"(":{"3":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}},"docs":{}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}},"和":{"docs":{},"s":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"在":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"j":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"中":{"docs":{},"，":{"docs":{},"但":{"docs":{},"仍":{"docs":{},"可":{"docs":{},"被":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"所":{"docs":{},"以":{"docs":{},"在":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"实":{"docs":{},"例":{"docs":{},"时":{"docs":{},"能":{"docs":{},"够":{"docs":{},"通":{"docs":{},"过":{"docs":{},"枚":{"docs":{},"举":{"docs":{},"类":{"docs":{},"型":{"docs":{},"中":{"docs":{},"的":{"docs":{},"成":{"docs":{},"员":{"docs":{},"名":{"docs":{},"称":{"docs":{},"单":{"docs":{},"独":{"docs":{},"引":{"docs":{},"用":{"docs":{},"。":{"docs":{},"在":{"docs":{},"上":{"docs":{},"面":{"docs":{},"的":{"docs":{},"例":{"docs":{},"子":{"docs":{},"中":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"属":{"docs":{},"性":{"docs":{},"能":{"docs":{},"正":{"docs":{},"确":{"docs":{},"得":{"docs":{},"输":{"docs":{},"出":{"docs":{},"对":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"牌":{"docs":{},"有":{"1":{"docs":{},"和":{"1":{"1":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"在":{"docs":{},"自":{"docs":{},"己":{"docs":{},"内":{"docs":{},"部":{"docs":{},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"嵌":{"docs":{},"套":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"这":{"docs":{},"个":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"包":{"docs":{},"含":{"docs":{},"两":{"docs":{},"个":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"只":{"docs":{},"有":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"有":{"docs":{},"两":{"docs":{},"个":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"其":{"docs":{},"余":{"docs":{},"牌":{"docs":{},"都":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"数":{"docs":{},"值":{"docs":{},"。":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"定":{"docs":{},"义":{"docs":{},"了":{"docs":{},"一":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"，":{"docs":{},"这":{"docs":{},"个":{"docs":{},"计":{"docs":{},"算":{"docs":{},"属":{"docs":{},"性":{"docs":{},"会":{"docs":{},"根":{"docs":{},"据":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},"，":{"docs":{},"用":{"docs":{},"适":{"docs":{},"当":{"docs":{},"的":{"docs":{},"数":{"docs":{},"值":{"docs":{},"去":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"实":{"docs":{},"例":{"docs":{},"，":{"docs":{},"并":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"给":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"。":{"docs":{},"对":{"docs":{},"于":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{},",":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"会":{"docs":{},"使":{"docs":{},"用":{"docs":{},"特":{"docs":{},"殊":{"docs":{},"数":{"docs":{},"值":{"docs":{},"，":{"docs":{},"对":{"docs":{},"于":{"docs":{},"数":{"docs":{},"字":{"docs":{},"面":{"docs":{},"值":{"docs":{},"的":{"docs":{},"牌":{"docs":{},"使":{"docs":{},"用":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"用":{"docs":{},"来":{"docs":{},"描":{"docs":{},"述":{"docs":{},"扑":{"docs":{},"克":{"docs":{},"牌":{"docs":{},"从":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"~":{"1":{"0":{"docs":{},",":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{},",":{"1":{"3":{"docs":{},"张":{"docs":{},"牌":{"docs":{},"，":{"docs":{},"并":{"docs":{},"分":{"docs":{},"别":{"docs":{},"用":{"docs":{},"一":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"表":{"docs":{},"示":{"docs":{},"牌":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},"。":{"docs":{},"(":{"docs":{},"这":{"docs":{},"个":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"类":{"docs":{},"型":{"docs":{},"的":{"docs":{},"值":{"docs":{},"不":{"docs":{},"适":{"docs":{},"用":{"docs":{},"于":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"j":{"docs":{},",":{"docs":{},"q":{"docs":{},",":{"docs":{},"k":{"docs":{"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"g":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0019047619047619048},"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.010810810810810811},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}},"e":{"docs":{},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}},"声":{"docs":{},"明":{"docs":{},"成":{"docs":{},"了":{"docs":{},"常":{"docs":{},"量":{"docs":{},"（":{"docs":{},"用":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"关":{"docs":{},"键":{"docs":{},"字":{"docs":{},"）":{"docs":{},"，":{"docs":{},"即":{"docs":{},"使":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.010830324909747292}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0048134777376654635}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"协":{"docs":{},"议":{"docs":{},"要":{"docs":{},"求":{"docs":{},"其":{"docs":{},"遵":{"docs":{},"循":{"docs":{},"者":{"docs":{},"必":{"docs":{},"须":{"docs":{},"拥":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"名":{"docs":{},"为":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.006666666666666667},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0053533190578158455}},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}}},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"e":{"docs":{},"-":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0013698630136986301}}}}}}},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}}}}}}},"­":{"docs":{},",":{"docs":{},"­":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"-":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0021413276231263384},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.003424657534246575}},"e":{"docs":{},"r":{"docs":{},"­":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"-":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{},"-":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"-":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"­":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"u":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0024067388688327317}}}}}},"h":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}},"s":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.002285714285714286}}}}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"o":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"j":{"docs":{},"u":{"docs":{},"l":{"docs":{},"i":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0055762081784386614}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.07006369426751592}},"(":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.012738853503184714}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.006369426751592357}}}}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.022292993630573247}}}}}}},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}},"[":{"docs":{},"i":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}},"数":{"docs":{},"组":{"docs":{},"的":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"类":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"很":{"docs":{},"简":{"docs":{},"单":{"docs":{},"的":{"docs":{},"类":{"docs":{},"，":{"docs":{},"它":{"docs":{},"只":{"docs":{},"有":{"docs":{},"一":{"docs":{},"个":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"属":{"docs":{},"性":{"docs":{},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"设":{"docs":{},"定":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"，":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}},"，":{"docs":{},"它":{"docs":{},"被":{"docs":{},"初":{"docs":{},"始":{"docs":{},"化":{"docs":{},"为":{"docs":{},"一":{"docs":{},"个":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}}}}}}}}}}}},"w":{"0":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"1":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}},"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.04864864864864865}},"和":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"的":{"docs":{},"数":{"docs":{},"量":{"docs":{},"来":{"docs":{},"构":{"docs":{},"造":{"docs":{},"一":{"docs":{},"个":{"docs":{},"新":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}},"附":{"docs":{},"属":{"docs":{},"脚":{"docs":{},"本":{"docs":{},"的":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"chapter2/12_Subscripts.html#gitbook_6492":{"ref":"chapter2/12_Subscripts.html#gitbook_6492","tf":0.005405405405405406}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.01951219512195122}},"定":{"docs":{},"义":{"docs":{},"成":{"docs":{},"变":{"docs":{},"量":{"docs":{},"，":{"docs":{},"因":{"docs":{},"为":{"docs":{},"它":{"docs":{},"的":{"docs":{},"值":{"docs":{},"无":{"docs":{},"需":{"docs":{},"在":{"docs":{},"i":{"docs":{},"f":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.013237063778580024}},"方":{"docs":{},"法":{"docs":{},"用":{"docs":{},"来":{"docs":{},"模":{"docs":{},"拟":{"docs":{},"骰":{"docs":{},"子":{"docs":{},"的":{"docs":{},"面":{"docs":{},"值":{"docs":{},"。":{"docs":{},"它":{"docs":{},"先":{"docs":{},"使":{"docs":{},"用":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"的":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"方":{"docs":{},"法":{"docs":{},"来":{"docs":{},"创":{"docs":{},"建":{"docs":{},"一":{"docs":{},"个":{"docs":{},"[":{"0":{"docs":{},"-":{"1":{"docs":{"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0012033694344163659}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"获":{"docs":{},"得":{"docs":{},"，":{"docs":{},"如":{"docs":{},"e":{"docs":{},"x":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},".":{"docs":{},"b":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},"。":{"docs":{},"你":{"docs":{},"也":{"docs":{},"可":{"docs":{},"以":{"docs":{},"通":{"docs":{},"过":{"docs":{},"调":{"docs":{},"用":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"r":{"docs":{},"a":{"docs":{},"w":{"docs":{"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"内":{"docs":{},"存":{"docs":{},"管":{"docs":{},"理":{"docs":{},"操":{"docs":{},"作":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"不":{"docs":{},"再":{"docs":{},"被":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.014925373134328358}},"a":{"docs":{},"l":{"docs":{},"增":{"docs":{},"加":{"docs":{},"a":{"docs":{},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}},"的":{"docs":{},"值":{"docs":{},"，":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"了":{"docs":{},"当":{"docs":{},"前":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"引":{"docs":{},"用":{"docs":{},"，":{"docs":{},"而":{"docs":{},"不":{"docs":{},"是":{"docs":{},"仅":{"docs":{},"仅":{"docs":{},"复":{"docs":{},"制":{"docs":{},"该":{"docs":{},"变":{"docs":{},"量":{"docs":{},"的":{"docs":{},"初":{"docs":{},"始":{"docs":{},"值":{"docs":{},"。":{"docs":{},"捕":{"docs":{},"获":{"docs":{},"一":{"docs":{},"个":{"docs":{},"引":{"docs":{},"用":{"docs":{},"保":{"docs":{},"证":{"docs":{},"了":{"docs":{},"当":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"结":{"docs":{},"束":{"docs":{},"时":{"docs":{},"候":{"docs":{},"并":{"docs":{},"不":{"docs":{},"会":{"docs":{},"消":{"docs":{},"失":{"docs":{},"，":{"docs":{},"也":{"docs":{},"保":{"docs":{},"证":{"docs":{},"了":{"docs":{},"当":{"docs":{},"下":{"docs":{},"一":{"docs":{},"次":{"docs":{},"执":{"docs":{},"行":{"docs":{},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"函":{"docs":{},"数":{"docs":{},"时":{"docs":{},"，":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.003952569169960474}}}}}}},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}},"c":{"docs":{},"h":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.00510204081632653},"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.012987012987012988},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"chapter2/10_Properties.html#gitbook_6488":{"ref":"chapter2/10_Properties.html#gitbook_6488","tf":0.0022222222222222222}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"i":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}},"x":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0055658627087198514}}}},"-":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}}},"k":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"a":{"docs":{},"y":{"docs":{},"l":{"docs":{},"e":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143}}}}},"t":{"docs":{},"y":{"docs":{},"a":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}},"n":{"docs":{},"e":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.004454342984409799}}}}},"e":{"docs":{},"i":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.0087527352297593},"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.005970149253731343},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}},"y":{"docs":{},"s":{"docs":{},"或":{"docs":{},"者":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.00437636761487965}}}}}}}},")":{"docs":{},"和":{"docs":{},"/":{"docs":{},"或":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"是":{"docs":{},"值":{"docs":{},"类":{"docs":{},"型":{"docs":{},"(":{"docs":{},"结":{"docs":{},"构":{"docs":{},"体":{"docs":{},"或":{"docs":{},"枚":{"docs":{},"举":{"docs":{},")":{"docs":{},"，":{"docs":{},"当":{"docs":{},"赋":{"docs":{},"值":{"docs":{},"或":{"docs":{},"调":{"docs":{},"用":{"docs":{},"发":{"docs":{},"生":{"docs":{},"时":{"docs":{},"，":{"docs":{},"它":{"docs":{},"们":{"docs":{},"都":{"docs":{},"会":{"docs":{},"被":{"docs":{},"拷":{"docs":{},"贝":{"docs":{},"。":{"docs":{},"相":{"docs":{},"反":{"docs":{},"，":{"docs":{},"如":{"docs":{},"果":{"docs":{},"键":{"docs":{},"(":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{},"s":{"docs":{},")":{"docs":{},"和":{"docs":{},"/":{"docs":{},"或":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"是":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"，":{"docs":{},"值":{"docs":{},"(":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"是":{"docs":{},"整":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"类":{"docs":{},"型":{"docs":{},"。":{"docs":{},"这":{"docs":{},"两":{"docs":{},"种":{"docs":{},"类":{"docs":{},"型":{"docs":{},"在":{"docs":{},"s":{"docs":{},"w":{"docs":{},"i":{"docs":{},"f":{"docs":{},"t":{"docs":{"chapter2/09_Classes_and_Structures.html#gitbook_6487":{"ref":"chapter2/09_Classes_and_Structures.html#gitbook_6487","tf":0.002583979328165375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}},"和":{"docs":{},"一":{"docs":{},"个":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}},"-":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}},"的":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.004395604395604396},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0006849315068493151}}}}}}},"l":{"docs":{},"v":{"docs":{},"i":{"docs":{},"n":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.003676470588235294}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.001142857142857143},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.014367816091954023},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.0010706638115631692}}},"g":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter2/17_Optional_Chaining.html#gitbook_6502":{"ref":"chapter2/17_Optional_Chaining.html#gitbook_6502","tf":0.0031847133757961785}}}}}}}},"o":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"w":{"docs":{},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.00975609756097561}}}}}}}}}}}}}}}}}}},"n":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555}}}}}},"u":{"docs":{},"b":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"chapter2/18_Type_Casting.html#gitbook_6504":{"ref":"chapter2/18_Type_Casting.html#gitbook_6504","tf":0.0066815144766146995}}}}}}}},"m":{"docs":{"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}}}},"q":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046}},"u":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"chapter1/02_a_swift_tour.html#gitbook_6468":{"ref":"chapter1/02_a_swift_tour.html#gitbook_6468","tf":0.0034285714285714284},"chapter2/19_Nested_Types.html#gitbook_6506":{"ref":"chapter2/19_Nested_Types.html#gitbook_6506","tf":0.015748031496062992}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.004878048780487805},"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500":{"ref":"chapter2/16_Automatic_Reference_Counting.html#gitbook_6500","tf":0.0019047619047619048},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}},";":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575}}}}},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0009523809523809524},"chapter3/03_Types.html#gitbook_6521":{"ref":"chapter3/03_Types.html#gitbook_6521","tf":0.002785515320334262}},";":{"docs":{},")":{"docs":{},"，":{"docs":{},"u":{"docs":{},"+":{"1":{"docs":{},"f":{"4":{"2":{"5":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}}}},"":{"docs":{},"":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0018587360594795538}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"o":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}},"?":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"（":{"docs":{},"）":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"k":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/04_Collection_Types.html#gitbook_6477":{"ref":"chapter2/04_Collection_Types.html#gitbook_6477","tf":0.002188183807439825}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"被":{"docs":{},"转":{"docs":{},"换":{"docs":{},"成":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"-":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0012121212121212121}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"大":{"docs":{},"于":{"docs":{},"字":{"docs":{},"母":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"大":{"docs":{},"于":{"docs":{},"字":{"docs":{},"符":{"docs":{},"串":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"y":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"将":{"docs":{},"会":{"docs":{},"排":{"docs":{},"在":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/07_Closures.html#gitbook_6483":{"ref":"chapter2/07_Closures.html#gitbook_6483","tf":0.0029850746268656717}}}}}}}}}}}}}}}}}},"求":{"docs":{},"余":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"比":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"取":{"docs":{},"模":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}}}}},"短":{"docs":{},"路":{"docs":{},"计":{"docs":{},"算":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"，":{"docs":{},"当":{"docs":{},"左":{"docs":{},"端":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"为":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}}},"（":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"-":{"docs":{},"c":{"docs":{},"i":{"docs":{},"r":{"docs":{},"c":{"docs":{},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{"chapter2/02_Basic_Operators.html#gitbook_6494":{"ref":"chapter2/02_Basic_Operators.html#gitbook_6494","tf":0.0024390243902439024}}}}}}}}}}}}}}}}}}}},"按":{"docs":{},"位":{"docs":{},"左":{"docs":{},"移":{"docs":{},"/":{"docs":{},"右":{"docs":{},"移":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter2/23_Advanced_Operators.html#gitbook_6514":{"ref":"chapter2/23_Advanced_Operators.html#gitbook_6514","tf":0.0018552875695732839}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"-":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}},"二":{"docs":{},"元":{"docs":{},"运":{"docs":{},"算":{"docs":{},"符":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}},"右":{"docs":{},"边":{"docs":{},"参":{"docs":{},"数":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"后":{"docs":{},"缀":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"的":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"子":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"中":{"docs":{},"包":{"docs":{},"含":{"docs":{},"了":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"可":{"docs":{},"选":{"docs":{},"链":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{},";":{"docs":{},"，":{"docs":{},"那":{"docs":{},"么":{"docs":{},"只":{"docs":{},"有":{"docs":{},"最":{"docs":{},"外":{"docs":{},"层":{"docs":{},"的":{"docs":{},"表":{"docs":{},"达":{"docs":{},"式":{"docs":{},"返":{"docs":{},"回":{"docs":{},"的":{"docs":{},"才":{"docs":{},"是":{"docs":{},"一":{"docs":{},"个":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"左":{"docs":{},"边":{"docs":{},"参":{"docs":{},"数":{"docs":{},"&":{"docs":{},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0009881422924901185}}}}}}}}}}},"、":{"docs":{},"\\":{"docs":{},"­":{"docs":{},"、":{"docs":{},"u":{"docs":{},"+":{"0":{"0":{"0":{"docs":{},"a":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}},"docs":{}},"docs":{}},"docs":{}}}}}},"未":{"docs":{},"转":{"docs":{},"义":{"docs":{},"的":{"docs":{},"反":{"docs":{},"斜":{"docs":{},"线":{"docs":{},"\\":{"docs":{},"、":{"docs":{},"回":{"docs":{},"车":{"docs":{},"符":{"docs":{},"（":{"docs":{},"c":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"g":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"t":{"docs":{"chapter2/03_Strings_and_Characters.html#gitbook_6475":{"ref":"chapter2/03_Strings_and_Characters.html#gitbook_6475","tf":0.0037174721189591076}}}},"e":{"docs":{},"d":{"docs":{},"-":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.006593406593406593},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.002054794520547945}},"-":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.008791208791208791},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.0027397260273972603}}}}}}}}}}}}},"）":{"docs":{},"\\":{"docs":{},"&":{"docs":{},"#":{"3":{"9":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}},"docs":{}},"docs":{}},"q":{"docs":{},"u":{"docs":{},"o":{"docs":{},"t":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.016544117647058824}}}}}}}}},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.013333333333333334}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"g":{"docs":{},"h":{"docs":{},"i":{"docs":{},"j":{"docs":{},"k":{"docs":{},"l":{"docs":{},"m":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"chapter2/08_Enumerations.html#gitbook_6485":{"ref":"chapter2/08_Enumerations.html#gitbook_6485","tf":0.0033333333333333335}}}}}}}}}}}},"_":{"docs":{"chapter2/01_The_Basics.html#gitbook_6473":{"ref":"chapter2/01_The_Basics.html#gitbook_6473","tf":0.0035398230088495575},"chapter2/05_Control_Flow.html#gitbook_6479":{"ref":"chapter2/05_Control_Flow.html#gitbook_6479","tf":0.0038095238095238095},"chapter2/06_Functions.html#gitbook_6481":{"ref":"chapter2/06_Functions.html#gitbook_6481","tf":0.0024242424242424242},"chapter2/11_Methods.html#gitbook_6490":{"ref":"chapter2/11_Methods.html#gitbook_6490","tf":0.002551020408163265},"chapter2/14_Initialization.html#gitbook_6496":{"ref":"chapter2/14_Initialization.html#gitbook_6496","tf":0.001838235294117647},"chapter2/20_Extensions.html#gitbook_6508":{"ref":"chapter2/20_Extensions.html#gitbook_6508","tf":0.0028735632183908046},"chapter2/21_Protocols.html#gitbook_6510":{"ref":"chapter2/21_Protocols.html#gitbook_6510","tf":0.0036101083032490976},"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.0029644268774703555},"chapter3/05_Declarations.html#gitbook_6525":{"ref":"chapter3/05_Declarations.html#gitbook_6525","tf":0.004282655246252677},"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.013186813186813187},"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.007662835249042145},"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533":{"ref":"chapter3/09_Summary_of_the_Grammar.html#gitbook_6533","tf":0.005479452054794521}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"_":{"docs":{"chapter3/04_Expressions.html#gitbook_6523":{"ref":"chapter3/04_Expressions.html#gitbook_6523","tf":0.001976284584980237}}}}}}},"、":{"docs":{},"基":{"docs":{},"本":{"docs":{},"多":{"docs":{},"语":{"docs":{},"言":{"docs":{},"面":{"docs":{},"（":{"docs":{},"b":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"chapter3/02_Lexical_Structure.html#gitbook_6527":{"ref":"chapter3/02_Lexical_Structure.html#gitbook_6527","tf":0.002197802197802198}}}}}}}}}}}}}}},"）":{"docs":{},"。":{"docs":{},"当":{"docs":{},"你":{"docs":{},"不":{"docs":{},"关":{"docs":{},"心":{"docs":{},"被":{"docs":{},"匹":{"docs":{},"配":{"docs":{},"的":{"docs":{},"值":{"docs":{},"时":{"docs":{},"，":{"docs":{},"可":{"docs":{},"以":{"docs":{},"使":{"docs":{},"用":{"docs":{},"此":{"docs":{},"模":{"docs":{},"式":{"docs":{},"。":{"docs":{},"例":{"docs":{},"如":{"docs":{},"，":{"docs":{},"下":{"docs":{},"面":{"docs":{},"这":{"docs":{},"段":{"docs":{},"代":{"docs":{},"码":{"docs":{},"进":{"docs":{},"行":{"docs":{},"了":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"3":{"docs":{"chapter3/07_Patterns.html#gitbook_6529":{"ref":"chapter3/07_Patterns.html#gitbook_6529","tf":0.0038314176245210726}}},"docs":{}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"length":6872},"corpusTokens":["0","0(空字符)、\\\\(反斜线)、\\t(水平制表符)、\\n(换行符)、\\r(回车符)、\\"(双引号)、\\'","0)。vendcoins方法声明numberofcoinstovend为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。vendcoin","0)中的元素0","0)会首先匹配case","0)将匹配一个纵坐标为0的点，并把这个点的横坐标赋给临时的常量x","0)，因此剩下的能够匹配(0","0)，宽度高度都是10","0)，是否在红色的x轴上，是否在黄色y轴上，是否在一个以原点为中心的4x4","0,$1,$2","0,1,2等。每一个没有被赋值的int","0..3","0..count","0..self","0..somecontainer.count","0..time","0.0","0.0)和size(width","0.0125","0.0254","0.0自动推导出它们的类型doubl","0.1","0.14159","0.25","0.37464991998171","0.5","0.729023776863283","0.914399970739201","00000000","00000001","00000100","00001000","00010000","00010001","000123.456","00111100","005","005000.76","02","0746381295[9","08","088haizi","09","0b","0b00000101","0b00001111","0b00010100","0b00111111","0b01011110","0b10001","0b10110010","0b11110000","0b11111100","0o","0o21","0x","0x0000ff","0x00ff00","0x11","0x66","0x99","0xc.3p0","0xcc","0xcc6699","0xcc6699和0x0000ff进行按位与运算，得到0x000099，无需向右移位了，所以结果就是0x99，即十进制的153","0xcc6699和0x00ff00的按位操作得到0x006600。然后向右移动8們，得到0x66，即十进制的102","0xcc6699和0xff0000进行按位与&操作就可以得到红色部分。0xff0000中的0了遮盖了oxcc6699的第二和第三个字节，这样6699被忽略了，只留下0xcc0000","0xff0000","0xfp-2","0xfp2","0x）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的指数(exponent)，在十进制浮点数中通过大写或者小写的e来指定，在十六进制浮点数中通过大写或者小写的p","0——编译器会正确的推断出x的类型int。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了let","0。移位过程中保持符号会不变，负数在接近0","0中x的类型首先根据0的类型进行推断，然后将该类型信息传递到根节点（变量x","0为fals","0为true的时候代码运行才会继续，也就是说，当age的值非负的时候。如果age的值是负数，就像代码中那样，ag","0到25","0和$1表示闭包中第一个和第二个string","0和maxpasseng","0始的列表(如数组)时，非常方便地从0","0或nil","0或空值（比如说0或nil）。swift","0是需要向正数走还是向负数走。currentvalu","0的数据项的值再次等于"six","0而不是1","0）只在for循环的生命周期里有效。如果想在循环结束后访问index的值，你必须要在循环生命周期开始前声明index","0，1，2","0，1，2，3","0，代表正数，另外7比特位二进制表示的实际值就刚好是4","0，你可以完全忽略类型而简写成var","0，或者对0","0，负数为1","1","1(11111111向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的0","1(11111111向左移1","1...10","1...3","1...4","1...5","1...amounttopad","1...digitindex","1...finalsquar","1...power","1.0","1.0\"（这个点在x等于1.0","1.0，1.0","1.21875e1","1.25","1.25e-2","1.25e2","1.5","1.8","10","10,000","10...99","10.0","100","100...999","100.0","1000...999_999","10000","10000.56","1000000","10000000","1000_000","100，结合性被初始化为none","102","103","105","107","1080","1080i","10^2","10^{-2","10^{2","10^－2","10_000","10_000.56","10x10","10中，如果number为16，则返回6，58返回8，510返回0","10为0，这时闭包会将字符串输出，而map","10可以总是作为一个digitnam","10次，使用0到9的半闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号_","10被传递给x","10，同时maxinputlevelforallchannel","11","110","111","11111110","11111111","11，则会将右声道的currentlevel","12","12,gener","12-side","12.1875","12.5663708","120","123","1234567890123456","123456789[0]返回9","123456789[1]返回8","1234_5678_9012_3456","125.0","125.0；同样，1.25e－2","127","128","1280","128054","128054，是一个十六进制1f436","12880","128，即二进制的10000000。用溢出减法减去去1后，变成了01111111，即uint8所能承载的最大整数127","13","130","132","135","139968.0","140","144","15","15)，表示向右上方移动正方形到如图所示橙色正方形的位置。设置属性center","15.0","150","153","159","16","160","16。十六进制中每两个字符是8比特位，所以移动16位的结果是把0xcc0000变成0x0000cc。这和0xcc是相等的，都是十进制的204","16变成了1，58变成了5，510变成了51","17","182","19","1920","195.m","1]，编译提也能推断出dict的类型是dictionary<str","1_000.0","1_000_000","1_000_000.000_000_1","1。person具有一个自判断residence属性，它的类型是resid","1个比特位(称为符号位)来表达这个整数是正数还是负数。0代表正数，1","1位时乘于2，右移1位时除于2","1到5的数字。index被赋值为闭区间中的第一个数字（1），然后循环中的语句被执行一次。在本例中，这个循环只包含一个语句，用来输出当前index","1千米等于1,000米，所以km计算型属性要把值乘以1_000.00来转化成单位米下的数值。类似地，1米有3.28024英尺，所以ft计算型属性要把对应的double值除以3.28024","1或减1","1时才为1","1的便捷运算符自增运算符++i","1的条件是两个输入数的同一位不同，如果相同就设为0","1的条件是两个输入数的同一位都不为0(即任意一个为1，或都为1","1的比较结果是bool类型，所以第二个例子可以通过类型检查。类似i","1的简写，而--i是i","1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。leveltrack","1，objective-c","1，代表负数，7个数值位要表达的二进制值是124，即128","1：答案2。它简洁地表达根据问题成立与否作出二选一的操作。如果问题成立，返回答案1","2","2\"（最高等级现在是2","2(associ","2)中的元组模式(x","2)的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，(x","2,000","2,100","2,953","2...2","2.0","2.0，4.0","2.5","2.71828","20","200","2000","2001","204","2048","21","2100","212.0","21位数字(和名称)，例如u+0061表示小写的拉丁字母a","22","23","24","240","243610.0","243_610","25","25.0","25.4.mm","255","26","273.15","29573.0","2^-2","2^2","2^{-2","2^{2","2_000","2中，加号+是二元运算符，它的两个操作数是值1和2","2倍，非常好，那余数是1","2和3。而两个指定构造器必须调用父类中唯一的指定构造器，这满足了规则1","2和3。这个父类没有自己的父类，所以规则1","2是a","2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128","2的整数。向左移动一个整型的比特位相当于把这个数乘于2，向右移一位就是除于2","2）。复杂些的运行算例如逻辑与运算符&&（如if","2：返回对应的type。我们可以用它来动态的获取某个instance的typ","3","3.0","3.0，1.0","3.1","3.14159","3.1415927","3.14159，0.1和-273.15","3.2","3.28084","3.59","3.69","3.75","3.79","3.ft","3.repetit","30","30.0","307017261","32","32.0","32767","32位平台上，int和int32","32位平台上，uint和uint32","33","35","35.0","360","364279588","3877.0","39","39;&'","39;,'","39;,'分隔。一旦使用了参数列表，就必须使用'in'关键字（在任何情况下都得这样做，包括忽略参数的名字，typ","39;.dynamictype'","39;.self'","39;?'","39;as'","39;in'","39;is'","39;type","39;unowned'","39;weak'","3_000_000_000_000","3可以直接和字面量0.14159","3和5。它用传入3和5","3条件为fals","3没有显式声明类型，而表达式中出现了一个浮点字面量，所以表达式会被推测为doubl","3的10次幂），从1（3的0次幂）开始做3","3的6倍是18","4","4...9","4.0","4.75会变成4，-3.9会变成-3","40","40.0","404","42","42.0","42.km","42495.0","42和-23","42并且没有标明类型，swift","42被绑定（赋值）给常量somevalu","43","480","4]]，array3d[0][1]是指[3","4]，array3d[0][1][1]则是指值4","4个string","4个元素，但0..count只数到3","4而不是0。优先级高的运算符要先计算，在swift和c","4，你先计算出4的多少倍会刚好可以容入9","5","5.0","5.0，5.0","5.2","50","5000.76","510","536","55357","55357)，第二个值为u+dc36","56374","58","59049","597","6","6,gener","6-side","6.0","60.0","60；同样，0xfp-2","64位平台上，int和int64","64位平台上，uint和uint64","65","68","69105","6月12日凌晨4:38，我用了整整一晚上的时间来进行最后的校对，终于可以在12","6的形式分组，其结果为-7","6被以(4","6项，而且不包括mapl","6，7，8","7","7,900","7.5","7.simpledescript","70","70.0","72","73","746381295[0","746381295[1","746381295[2","746381295[8","746381295[9","75","77","777","7900","7，类型属性maxinputlevelforallchannel","8","8.0","8590951226","85909_51226","86","87","896","8:09","8位无符号整数类型是uint8，32位有符号整数类型是int32","8除于2.5等于3余0.5，所以结果是一个double值0.5","8，16，32和64","9","9.3","9.45","9.9","90","94","95;_column__","95;_file__","95;_function__","95;_line__","9900","9和4代入等式中，我们得1","9和4代入等式，-2","9天就完成整本书的翻译。我不知道大家付出了多少，牺牲了多少，但是我知道，他们的付出必将被这些文字记录下来，即使再过10年，20","9天时间，1317","9的行星，通过fromraw返回的可选planet值将是nil","_","_column_","_file_","_function_","_line_","_、基本多语言面（basic","_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了1...3","a++.b","a++，是先返回了a的值，然后a才加1。所以c得到了a的旧值1，而a加1后变成2","a+b","a,b,c","a...b）定义一个包含从a到b(包括a和b","a..b和a...b","a..b）定义一个从a到b但不包括b","a.adjust","a.append(4","a.simpledescript","a[0","aardvark","abcdefghijklmnop","ac","access","ace.toraw","acerawvalu","act","act1scenecount","actual)拷贝才会被执行。swift","actualnumb","actualnumber常量可以在if语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用!后缀来获取它的值。在这个例子中，actualnumb","ad","add","addon","addone(numb","address","address。它有三个自判断属性他们额类型是string?。前面两个自判断属性buildingnam","address实例时的使用（john.residence.address）。john.residence属性是一个可选类型，因此你需要在它获取address","address类中的buildingidentifi","address类还提供了一个buildingidentifier的方法，它的返回值类型为string?。这个方法检查buildingname和buildingnumber的属性，如果buildingname有值则将其返回，或者如果buildingnumb","address设定一个实例来作为john.residence.address的值，并为address的street","addthesecondnumb","addthesecondnumber(b","addtwoint","addtwoints(a","addtwoints，并输出结果：8","addtwonumbers(4)(5","addtwonumbers(a","adescript","adjust","adopt","advanc","advancetolevel(level","afterdoubl","afterincr","ag","again","ages的字典，其中储存了四个人的名字和年龄。ages字典被赋予了一个名为copiedages的新变量，同时ages在赋值的过程中被拷贝。赋值结束后，ages和copiedag","airport","airport'","airportcod","airportnam","airports.count","airports.kei","airports.removevalueforkey(\"dub","airports.updatevalue(\"dublin","airports.valu","airports[\"apl","airports[\"dub","airports[\"lhr","airports字典使用字典字面语句初始化，包含两个键值对。第一对的键是tyo，值是tokyo。第二对的键是dub，值是dublin","airports字典被声明为变量（用var关键字）而不是常量（let","airports字典被定义为一种dictionary<str","alex","alia","aliases)就是给现有类型定义另一个名字。你可以使用typealia","alien","alignright","alignright(originalstr","alignright(var","alik","allitemsmatch","allitemsmatch(stackofstr","allitemsmatch的泛型函数，用来检查是否两个container单例包含具有相同顺序的相同元素。如果匹配到所有的元素，那么返回一个为true的boolean","allitemsmatch首先检查两个容器是否拥有同样数目的items，如果他们的元素数目不同，没有办法进行匹配，函数就会fals","allow","allowedentri","alow","alsoincrementbyten","alsominussix","alsoposit","alsoteneighti","alsoteneighty.framer","alsoteneighty的新常量，同时对alsoteneighti","alsotentighti","alt","alt=\"comput","alt=\"stat","alternativerect","amarathon","ami","amount","amounttopad","amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor","amount和numberoftimes。默认情况下，swift","amount当作一个局部名称，但是把numberoftim","amount或者runningtotal来声明在嵌入的incrementor","amount，表示每次incrementor被调用时runningtot","amp","amp;&","amp;&和||的复合逻辑。但无论怎样，&&","amp;/和&%进行除0操作时就会得到0","amp;­identifi","andrea","anim","animal(leg","animalnam","anish","anna","annot","anonym","anoth","anothercharact","anothercontain","anothercontainer.count","anothercontainer[i","anothercontainer是一个c2","anotheremptystr","anotherint","anothermathfunct","anotherpi","anotherpoint","anotherproctocol","anotherproperti","anotherprotocol","anotherprotocol>这样的格式进行组合，称为协议合成(protocol","anotherstr","anotherthreedoubl","anothertwothre","anothervalu","anothervector","answer","answer1","answer2","ant","anycommonel","anycommonelements([1","anyobject","anyobject可以代表任何class","any可以表示任何类型，除了方法类型（funct","any和anyobject","apart","apartment(numb","apartment实例有一个叫number，类型为int的属性，并有一个可选的初始化为nil的tenant属性。ten","apartment实例的强引用来自于变量number73。如果你断开这个强引用，再也没有指向apart","api","apis，它一般接收一个anyobject","apl","append","append(item","appending),插入(inserting),删除(removing)或者使用范围下标(rang","append方法添加一个新item","appl","applese","applesummari","appropri","arbitrari","arc","arc）这一机制来跟踪和管理你的应用程序的内存。通常情况下，swift","area","area:≈radiu","argument","argyrio","arithmet","arithmeticmean(1","arithmeticmean(3","arithmeticmean(numb","arrai","array<int>>","array<int>替代泛型类型array<t>的类型形参t","array<sometype>这样的形式，其中sometyp","array(airports.kei","array(airports.valu","array(count","array)和字典(dictionari","array-liter","array-literal-item","array-literal-items­opt","array-literal-item­,­(opt","array-literal-item­,­array-literal-item","array-typ","array3d","array3d[0]是指[[1","array$0、$1、$2`。例如，class`class`。反引号不属于标识符的一部分，`x`(x","comparable等同于t","comparable表示任何用于替代类型形参t的类型实参必须满足compar","comparable，等等），但是依然可以用来对类型形参及其关联约束提供更复杂的约束。如，<t","compasspoint","compasspoint.west","compasspoints例子中，north，south，east和west不是隐式的等于0，1，2和3。相反的，这些不同的枚举成员在compasspoint","compasspoint和planet","compil","compile-tim","completedlevel(level","composit","compound","comput","computedtypeproperti","concaten","condit","condition(item","conditional-oper","conditional-operator­prefix-express","condition的值在statements执行前就已计算出，因此while语句中的stat","condition表达式的值是在statements表达式执行后才计算出，因此do-while语句中的stat","condition表达式的值的类型必须遵循logicvalue协议。同时，condit","conform","conformance-requir","congruenti","conjunct","consid","conson","constant","constant-declar","constantnam","constantstr","constrain","contain","container协议声明了一个itemtype的关联类型，写作typealia","container协议的例子，定义了一个itemtyp","container协议的泛型stack","container协议的类型必须指定存储在其里面的值类型，必须保证只有正确类型的items可以加进容器里，必须明确可以通过其下标返回item","container协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。container协议需要指定任何通过append","containsave","containscharact","containscharacter(#str","containscharacter(str","contentheight","context","context）单表达式闭包隐式返回（implicit","continu","continue-stat","continue、break和fallthrough语句。return","continue语句用于终止循环中当前迭代的执行，但不会终止该循环的执行。使用continue语句时，可以只写continue这个关键词，也可以在continue后面跟上标签名(label","continue语句的例子，请参考控制流一章的continu","continue语句，使本次循环迭代结束，从新开始下次循环迭代。这种行为使switch","control","control-transfer-stat","conveni","convert","convertednumb","convertedrank","convertedrank.simpledescript","copi","copiedag","copiedages[\"pet","copiednam","copiedname[0","copy方法进行强制显性复制。这个方法对数组进行了浅拷贝(shallow","count","count(\"som","count(str","countedth","countel","countelements(str","countelements(stringtoprint","countelements(unusualmenageri","countelements返回的字符数量并不总是与包含相同字符的nsstring的length属性相同。nsstring的length","counter","counter.count","counter.datasourc","counter.incr","counter.incrementby(2","counter.incrementby(5","counter.reset","counterdatasourc","counterdatasource含有incrementforcount的可选方法和fiexdincr","counter中已经示范了：counter中的三个实例方法中都使用的是count（而不是self.count","counter的另一个版本（它定义了一个更复杂的incrementbi","counter类使用counterdatasource类型的外部数据源来提供增量值(incr","counter类含有counterdatasource?类型的可选属性datasourc","counter这个类还声明了一个可变属性count","counter，count","countri","country(area","country(nam","country.capitalcity.nam","country和city的实例，而不产生循环强引用，并且capitalc","country和city，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，country类拥有一个capitalcity属性，而city类有一个countri","country的构造函数调用了city的构造函数。然而，只有country的实例完全初始化完后，country的构造函数才能把self传给c","count属性用于存储当前的值，increment方法用来为count","count属性获取容器里items的数量，并返回一个int","count属性进行比较来在使用某个索引之前先检验是否有效。除了当count","coverxit","cow","creditcard","creditcard(numb","cuatro","cuboid","cuboid(width","cuboid的结构体，表示三维空间的立方体，包含width、height和depth属性，还有一个名为volume的只读计算属性用来返回立方体的体积。设置volume的值毫无意义，因为通过width、height和depth就能算出volume。然而，cuboid","cucumb","cun","current","currentdirect","currentlevel","currentlevel值大于任何之前任意audiochannel实例中的值，属性监视器将新值保存在静态属性maxinputlevelforallchannel","currentlevel包含didset","currentlevel属性，leveltracker定义了实例方法advancetolevel。这个方法会在更新currentlevel之前检查所请求的新等级是否已经解锁。advancetolevel方法返回布尔值以指示是否能够设置currentlevel","currentlevel的新值大于允许的阈值thresholdlevel，属性监视器将currentlevel的值限定为阈值thresholdlevel","currentloginattempt","currentvalu","curri","curtiz","custom","customer(nam","customer和creditcard","customer和creditcard之间的关系与前面弱引用例子中apartment和person的关系截然不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，customer类有一个可选类型的card属性，但是creditcard类有一个非可选类型的custom","customer和creditcard的例子展示了一个属性的值允许为nil，而另一个属性的值不允许为nil","customer实例持有对creditcard实例的强引用，而creditcard实例持有对custom","customer实例的强引用，该实例被销毁了。其后，再也没有指向creditcard","customer的无主引用，当你断开john变量持有的强引用时，再也没有指向custom","customer类的实例，用它初始化creditcard实例，并将新创建的creditcard实例赋值为客户的card","c兼容性的限制。swift","c继承而来的新协议protocol","c语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。swift","c语言中的数值计算，swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加&+。所有允许溢出的运算符都是以&","c，c","d","d12","d6","d6.roll","d``o``g``!和🐶(dog","dabing1022","dai","daniella","data","data.txt","dataimport","dataimporter和datamanag","datamanag","datamanager也可能不从文件中导入数据。所以当datamanager的实例被创建时，没必要创建一个dataimporter的实例，更明智的是当用到dataimport","datamanager的一个功能是从文件导入数据，该功能由dataimporter类提供，dataimport","datamanager类包含一个名为data的存储属性，初始值是一个空的字符串（string）数组。虽然没有写出全部代码，datamanag","datasourc","datasource?.fixedincr","datasource?.incrementforcount?(count","datasource可能为nil，因此在datasource后边加上了?标记来表明只在datasource非空时才去调用incrementforcount","datasource存在，但是也无法保证其是否实现了incrementforcount方法，因此在incrementforcount","dave","dc","decim","decimal-digit","decimal-expon","decimal-fract","decimal-liter","decimal-literal-charact","decimalbas","decimaldoubl","decimalinteg","declar","declaration-specifi","declaration-specifier­declaration-specifiers­opt","declarations­opt","declaration­declarations­opt","decompos","decrement","default","default-argument-claus","default-label","defaultrect","default）分支满足该要求，这个默认分支必须在switch","defin","definit","definitestr","deinit","deiniti","deinitializer-declar","deinit来标示析构函数，类似于初始化函数用init","deleg","delegate?.game(self,didstartnewturnwithdicerol","delegate?.gamedidend(self","delegate?.gamedidstart(self","delegate不为nil","delegate属性为nil","delegate并不是该游戏的必备条件，delegate被定义为遵循dicegamedeleg","delegate是一个遵循dicegamedelegate的可选属性，因此在plai","deltai","deltax","deni","depth","descript","design","diamond","dic","dice","dice(sid","dice.rol","dicegam","dicegamedeleg","dicegamedelegate协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即plai","dicegametrack","dicegametracker实现了dicegamedeleg","dicegametracker遵循了dicegamedeleg","dicegame协议可以在任意含有骰子的游戏中实现，dicegamedelegate协议可以用来追踪dicegam","dicerol","diceroll:int","diceroll的值并不是一个随机数，而是以0为初始值，之后每一次while循环，diceroll的值使用前置自增操作符(++i","diceroll调用完成后，返回值等于diceroll自增后的值。任何时候如果diceroll的值等于7时，就超过了骰子的最大值，会被重置为1。所以diceroll的取值顺序会一直是1，2，3，4，5，6，1，2","dice含有sides和generator两个属性，前者用来表示骰子有几个面，后者为骰子提供一个随机数生成器。由于后者为randomnumbergener","dice的类，用来代表桌游中的n","dice类型的实例可被当作textrepresent","dice类遵循textrepresent","dict","dictionari","dictionary<keytyp","dictionary<str","dictionary-liter","dictionary-literal-item","dictionary-literal-item,­(opt","dictionary-literal-item­,­dictionary-literal-item","dictionary(arrai","equatable类型都可以安全的使用在findindex函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个equat","equatable，也就意味着“任何t类型都遵循equat","equilater","equilateraltriangl","equilateraltriangle(sidelength","equival","ericzyh","error","error(error","error(str","escaped-charact","evaluation）"","even","everyth","evilcom","ewa","eww","exampleclass","exampleenum","exampleenum.a的值是0，exampleenum.b的值是。因为exampleenum.c的值被显式的设定为5","exampleenum.d的值会自动增长为6","examplemodule.mytyp","exampleprotocol","except","execut","exist","explicit","explicit-member-express","explicitdoubl","exponentdoubl","export","express","expression)。起保护作用的表达式是这样构成的：关键字where后面跟着一个作为额外测试条件的表达式。因此，当且仅当控制表达式匹配一个case的某个模式且起保护作用的表达式为真时，对应case块中的statements才会被执行。在下面的例子中，控制表达式只会匹配含两个相等元素的元组，如(1","expression)会首先被计算，然后与每一个case的模式(pattern)进行匹配。如果匹配成功，程序将会执行对应的case块里的statements。另外，每一个case块都不能为空，也就是说在每一个case块中至少有一条语句。如果你不想在匹配到的case块中执行代码，只需在块里写一条break","expression)，switch","expression-el","expression-element-list","expression-element­,­expression-element-list","expression-list","expression-pattern","expression.dynamictyp","expression.init（initi","expression.memb","expression.self","expression[index","expressions）sort","expressions）二元表达式（binari","expressions）函数调用表达式（funct","expressions）前缀表达式（prefix","expressions）字符型表达式（liter","expressions）赋值表达式（assign","expression­,­expression-list","expression­:­express","expression）dynamic表达式（dynam","expression）self表达式（self","expression）。通常会增加或减少计数器的值，或者根据语句（stat","expression）初始化函数表达式（initi","expression）可选链表达式（optional-chain","expression）后缀self表达式（postfix","expression）后缀表达式（postfix","expression）圆括号表达式（parenthes","expression）强制取值表达式（forced-valu","expression）显式成员表达式（explicit","expression）被调用，如果表达式调用结果为false，循环结束，继续执行for","expression）超类表达式（superclass","expression）通配符表达式（wildcard","expression）闭包表达式（closur","expression）附属脚本表达式（subscript","expression）隐式成员表达式（implicit","exp，那这个数相当于基数和$10^{exp","exp，那这个数相当于基数和$2^{exp","extend","extens","extension-bodi","extension-declar","extensions）扩展语法（extens","extension­type-identifier­type-inheritance-clause­opt­extension-bodi","extern","f","f()和f(x:7)都是只有一个变量x的函数的有效调用，但是f(7","f(7","f(x","f.temperatur","face字符的utf-16","face的4","face的unicod","face，unicod","fahrenheit","fahrenheit时为属性temperatur","fahrenheit，它拥有一个double类型的存储型属性temperatur","fail","failur","fall","fallthrough","fallthrough-stat","fallthrough关键字。下面的例子使用fallthrough","fallthrough语句可出现在switch语句中的任意case里，但不能出现在最后一个case块中。同时，fallthrough语句也不能把控制权传递给使用了可选绑定的cas","fallthrough语句用于在switch语句中传递控制权。fallthrough语句会把控制权从switch语句中的一个case传递给下一个case。这种传递是无条件的，即使下一个case的值与switch","fallthrough语句，详情请参考贯穿（fallthrough","fallthrough）区间匹配（rang","fals","false。同样的，item","false，但是我们是知道紧急情况下重置的密码的，所以整个复杂表达式的值还是tru","false，整个表达式的值就为false。事实上，如果第一个值为fals","fd5788","feed","feed）\\n","feed）（u+000a）、回车符（carriag","feed）（u+000c）以及空（null）（u+0000","feet","few","fibonacci","filenam","file），它返回的是当前modul","final","finalsquar","finalsquare、board、square和dicerol","finalsquare）和while方式相同，但是只会在循环结束后进行计算。在这个游戏中，do-while表现得比while循环更好。do-while方式会在条件判断square没有超出后直接运行squar","finalsquare，这表明你必须刚好落在方格25","final来防止它们被重写，只需要在声明关键字前加上@final特性即可。（例如：@fin","findindex([\"mik","findindex([3.14159","findindex(arrai","findindex中这个单个类型参数写做：t","findindex函数现在则可以成功的编译过，并且作用于任何遵循equatable的类型，如double或str","findindex，用某个类型t","findstringindex","findstringindex(arrai","findstringindex(str","findstringindex的泛型版本findindex。请注意这个函数仍然返回int","findstringindex的非泛型函数，该函数功能是去查找包含一给定string值的数组。若查找到匹配的字符串，findstringindex函数返回该字符串在数组中的索引值（int），反之则返回nil","first","first-class）类型。它们采用了很多传统上只被类（class)所支持的特征，例如计算型属性（comput","firstbit","firstbits和otherbits都有一个1跟另一个数不同的。所以按位异或的结果是把它这些位置为1，其他都置为0","firstforloop","firstitem","firstnumb","firstnumber是一个值为10的常量，secnodename是一个值为42","firstprotocol","firstroomnam","firstsixbit","firstsixbits和lastsixbits中间4个位都为1。对它俩进行按位与运算后，就得到了00111100，即十进制的60","firstvalu","firstvector","five","fiveeight","fiveonezero","fixedincr","fixedlengthrang","fixedlengthrange(firstvalu","fixedlengthrange的实例包含一个名为firstvalue的变量存储属性和一个名为length的常量存储属性。在上面的例子中，length","fixedpoint","fixedpoint.movebyx(2.0","flat","float","floating-point","floating-point-","floating-point-liter","floating-point-p","float并指定初始值为4","float表示32","flour","flow","flow）中介绍，当考虑一个枚举的成员们时，一个switch语句必须全面。如果忽略了.west这种情况，上面那段代码将无法通过编译，因为它没有考虑到compasspoint","follow","food","food(nam","food、recipeingredient以及shoppinglistitem","food的子类recipeingredient。recipeingredient类构建了食谱中的一味调味剂。它引入了int类型的数量属性quantity（以及从food继承过来的name属性），并且定义了两个构造器来创建recipeingredi","food类中的构造器init(nam","food类提供了一个接受单一参数name的指定构造器。这个构造器可以使用一个特定的名字来创建新的food","food，它是一个简单的用来封装食物名字的类。food类引入了一个叫做name的string类型属性，并且提供了两个构造器来创建food","for-in","for-in-stat","for-infor条件递增（for-condition-increment）whil","for-init","for-in循环和半闭区间操作（..）来迭代somecontainer中的所有元素。对于每个元素，函数检查是否somecontainer中的元素不等于对应的anothercontainer中的元素，如果这两个元素不等，则这两个容器不匹配，返回fals","for-in循环来遍历字符串中的字符（charact","for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都由(kei","for-in循环的介绍请参见for","for-in循环请参见for","for-in循环，swift","for-in循环，用来更简单地遍历数组（array），字典（dictionary），区间（range），字符串（str","for-in用来遍历一个区间（range），序列（sequence），集合（collection），系列（progress","for-in语句允许在重复执行代码块的同时，迭代集合(或遵循sequ","for-in语句在循环开始前会调用collection表达式的generate方法来获取一个生成器类型（这是一个遵循generator协议的类型）的值。接下来循环开始，调用collection表达式的next方法。如果其返回值不是none，它将会被赋给item，然后执行statements，执行完毕后回到循环开始处；否则，将不会赋值给item也不会执行statements，for-in","for-in语句或者变量或常量申明时，它可以包含通配符模式，标识符模式或者其他包含这两种模式的模式。例如，下面这段代码是不正确的，因为(x","for-stat","forc","force-unwrap","forced-valu","forced-value-express","forget","forkei","fork，超过30人参与翻译和校对工作，项目最高排名github总榜第4","form","for—that","for和while循环，基于特定条件选择执行不同代码分支的if和switch语句，还有控制流程跳转到其他代码的break和continu","for循环用来按照指定的次数多次执行一系列语句。swift","for条件递增（for-condition-incr","for条件递增（for-condition-increment）循环体中，在调用continu","for条件递增（for-condition-increment）循环，swift","for语句、for-in语句、while语句和do-whil","for语句中，continue语句执行后，increment表达式还是会被计算，这是因为每次循环体执行完毕后incr","found","found"","found")元组把一个int值和一个str","foundat","foundindex","four","fourbyfivebytwo","fourbyfivebytwo.volum","framer","freezingpointofwat","freezingpointofwater.temperatureincelsiu","friar","friendlywelcom","friendlywelcome的值从"hello!"改为了"bonjour!"","fromfahrenheit，内部名字为fahrenheit；第二个构造器也拥有一个构造参数，其外部名字为fromkelvin，内部名字为kelvin。这两个构造器都将唯一的参数值转换成摄氏温度值，并保存在属性temperatureincelsiu","fromraw方法来试图找到具有特定原始值的枚举成员。这个例子通过原始值7识别uranu","fromthetop","fruit","fruitsummari","ft","fullnam","fullynam","fullynamed协议含有fullname属性。因此其遵循者必须含有一个名为fullname，类型为str","func","function","function-bodi","function-call-express","function-declar","function-head","function-head­function-name­generic-parameter-clause­opt­function-signatur","function-nam","function-result","function-signatur","function-typ","functions）函数参数与返回值（funct","functions）函数的定义与调用（defin","functions）尾随闭包（trail","functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nest","function）中，__function__","function）的类型相当于一个嵌套函数类型。例如，下面的柯里化函数addtwonumber()()的类型是int","function）闭包表达式语法（closur","func关键字之前加上关键字class；声明结构体和枚举的类型方法，在方法的func关键字之前加上关键字stat","func来声明一个函数，使用名字和参数来调用函数。使用->","g","game","game(gam","game,d12,simothehamst","game.deleg","game.dice.sides)-sid","game.plai","gamedidend(gam","gamedidstart(gam","gamedidstart方法从game参数获取游戏信息并输出。game在方法中被当做dicegame类型而不是snakeandladders类型，所以方法中只能访问dicegam","gameloop","gameloop去跳转到下一次循环迭代时，这里使用gameloop标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以continue语句会影响到哪个循环体是没有歧义的。然而，continue语句使用gameloop标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的break","gameloop语句结束本次whil","gameloop语句跳转控制去执行whil","gear","geek5nan","gener","generator.random","generic-argu","generic-argument-claus","generic-argument-clause[opt","generic-argument-clause[opt].type-identifi","generic-argument-list","generic-argument­,­generic-argument-list","generic-paramet","generic-parameter-claus","generic-parameter-list","generic-parameter­,­generic-parameter-list","getgaspric","gettable，但它不要求属性是存储型属性(stor","getter","getter-claus","getter-keyword-claus","getter-sett","getter-setter-block","getter-setter-keyword-block","getter-setter方法​​块可以由一个getter子句后跟一个可选的setter子句构成，用大括号括起来，或者由一个setter子句后跟一个gett","getter/sett","getters和sett","getters和setters。（译者注：getters和sett","getter和sett","getter和setter。如果附属脚本申明包含get和set","getter和setter要求。结果就是你不需要在协议里它被声明的地方实现getter和sett","getter和setter要求可以通过一致性类型以各种方式满足。如果属性声明包含get和set关键词，一致性类型就可以用可读写（实现了getter和setter）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含get","getter和setter语句。如果附属脚本声明值包含get","getter用于读取值，setter用于写入值。setter子句是可选的，当仅需要一个getter子句时，可以将二者都忽略且直接返回请求的值即可。也就是说，如果使用了setter子句，就必须使用gett","getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有gett","getter获取某个值，或者通过sett","getter语句，可以选择是否包含sett","get代码块中的代码写在subscript","get关键字表示。它们的返回值是double型，而且可以用于所有接受doubl","get部分返回值是int?，上例中的numberoflegs字典通过下边返回的是一个int?或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是nil；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为nil","ghostbust","give","given","global","goe","gonna","good","goodby","graham","grammar","graphem","great","green","greencompon","greet","greet(\"bob","greet(nam","grid","grid[(row","grtmndsthnklk","gt","gt;>","gt;"","gt;infix-operator-declar","gt;­attribut","gt;­attributes­opt­typ","gt;！&","guard","guard-claus","guard-express","h","half-clos","halfopenrangelength(start","hall","hamster","hamster(nam","hamster的实例可以作为textrepresent","haolloyin","happi","happym","harmless","hasanymatches(list","hasanymatches(numb","hasarea","hasarea协议时，通过as?操作符将其可选绑定(opt","hasdoorkei","hasdoorkey）为false，但第二个值（knowsoverridepassword）为true，所以整个表达是tru","hashabl","hashable和valuetype产生的。每一个类型实参必须满足它所替代的泛型形参的所有约束，包括任何where语句所指定的额外的要求。上面的例子中，类型形参keytype要求满足hashable协议，因此string也必须满足hash","hashead","hasprefix","hasprefix/hassuffix","hassuffix","hawk","hawstein","hd","hd.width","hd实例中width属性还是1920","hd的常量，其值为一个初始化为全高清视频分辨率(1920","hd赋予给cinema的时候，实际上是将hd中所储存的值(values)进行拷贝，然后将拷贝的数据储存到新的cinema实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将cinema的width修改为2048并不会影响hd中的宽(width","heart","hearts.simpledescript","heartsdescript","heartssymbol","hearts成员：给hearts常量赋值时，枚举成员suit.hearts需要用全名来引用，因为常量没有显式指定类型。在switch里，枚举成员使用缩写.hearts来引用，因为self的值已经知道是一个suit","heathrow","height","height=\"120","height=\"169","height=\"357","height=\"387","heigth","hello","hello-world","help","here","here'","hexadecim","hexadecimal-digit","hexadecimal-expon","hexadecimal-fract","hexadecimal-liter","hexadecimal-literal-charact","hexadecimaldoubl","hexadecimalinteg","high","highest","highestunlockedlevel","highland","hilari","honghaoz","horizont","horribl","hors","html","htmlelement","htmlelement(nam","htmlelementdeinitializer中的消息并没有别打印，证明了htmlel","htmlelement例子中，无主引用是正确的解决循环强引用的方法。这样这样编写htmlel","htmlelement实现和之前的实现一致，只是在ashtml闭包中多了一个占有列表。这里，占有列表是[unown","htmlelement类产生了类实例和ashtml","htmlelement类只提供一个构造函数，通过name和text（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当htmlel","htmlelement类定义了一个name属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。htmlelement还定义了一个可选属性text","htmlelement还定义了一个lazy属性ashtml。这个属性引用了一个闭包，将name和text","http","http200statu","http200status.descript","http200status.statuscod","http404error","http404error.0","http404error.1","human","hundr","i++的特性，不然推荐你使用++i和--i","iboutlet和ibinspectable用于修饰一个类的属性声明；ibaction特性用于修饰一个类的方法声明；ibdesign","ident","identifi","identifier-charact","identifier-head","identifier-list","identifier-list­function-result­(opt)­in","identifier-pattern","identifier-patterntype-annotationopt","identifier­:­express","identifier­generic-argument-clause(opt","if-condit","if-stat","if和let来处理值缺失的情况。有些变量的值是可选的。一个可选的值可能是一个具体的值或者是nil","if和switch来进行条件操作，使用for-in、for、while和do-whil","if或els","if语句中条件的值的类型必须遵循logicvalu","if语句中，条件必须是一个布尔表达式——这意味着像if","if语句允许二选一，也就是当条件为fals","if语句和switch","if语句和switch语句。通常，当条件较为简单且可能的情况很少时，使用if语句。而switch语句更适用于条件较复杂、可能情况较多且需要用到模式匹配（pattern-match","if语句最简单的形式就是只包含一个条件，当且仅当该条件为tru","if语句来判断一个可选是否包含值。如果可选有值，结果是true；如果没有值，结果是fals","if语句用于判断是不是特别热。而最后的els","if语句的第一个分支中操作actualnumber的值，你可以改成if","if语句类似。与之不同的是，switch","if！allowedentri","ignor","imag","img","implement","implicit","implicit-member-express","implicit-parameter-nam","implicitdoubl","implicitinteg","implicitli","implicitly-unwrapped-optional-typ","implicitlyunwrappedoptional解决实例之间的循环强引用解决实例之间的循环强引用弱引用无主引用泛型实参语句泛型形参语句泛型形参语句where语句hello","pad","paddeddoubl","paddedstr","paint","pair","pairs）。遍历字典时，字典的每项元素会以(kei","paragraph","paragraph变量为nil，打破它持有的htmlelement实例的强引用，htmlel","paragraph变量定义为可选htmlelement，因此我们可以赋值nil","parakeet","paramet","parameter)，不支持默认参数(default","parameter-claus","parameter-clause­function-result­(opt)­in","parameter-list","parameter-list­...­opt","parameter-nam","parameternam","parameters"","parameters)或返回类型(return","parameters)指定一个或多个用于在相关类型的附属脚本中访问元素的索引（例如，表达式object[i]中的i）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。返回类型(return","parameters）函数类型（funct","parameters）常量参数和变量参数（const","parameters）无参函数（funct","parameters）无返回值函数（funct","parameters）输入输出参数（in-out","parameter­,­parameter-list","parent","parenthes","parenthesized-express","passedretinascan","passeng","pattern","pattern-initi","pattern-initializer-list","pattern-matched)的，和其相反的是switch语句case块中枚举事件匹配，在枚举事件类型(enumer","patternastyp","patterns）表达式模式（express","patterns）通配符模式（wildcard","pattern）代表了单个值或者复合值的结构。例如，元组(1","pattern）值绑定模式（value-bind","pattern）元组模式（tupl","pattern）和元组模式（tupl","pattern）枚举案例模式（enumer","pattern）标识符模式（identifi","pattern）类型转换模式（type-cast","pattern），标识符模式（identifi","penguin","pepper","performact","perimet","person","person'","person(fullnam","person(nam","person?的变量，用来按照代码片段中的顺序，为新的person实例建立多个引用。由于这些变量是被定义为可选类型（person?，而不是person），它们的值会被自动初始化为nil，目前还不会引用到person","personnam","person和apart","person和apartment实例并将类实例赋值给john和number73","person和apartment的例子一致，但是有一个重要的区别。这一次，apartment的ten","person和apartment的例子展示了两个属性的值都允许为nil","person和resid","person和residence模型通过添加一个room和一个address","person实例依然保持对apartment实例的强引用，但是apartment实例只是对person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向person","person实例有一个类型为string，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apart","person实例现在有了一个指向apartment实例的强引用，而apartment实例也有了一个指向person实例的强引用。因此，当你断开john和number73","person实例的引用数量，并且会在person","person实例，它的resid","person实例，这也意味着你不再使用这个person","person类开始，并定义了一个叫nam","person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。person","person类的新实例被赋值给了reference1变量，所以reference1到person类的新实例之间建立了一个强引用。正是因为这个强引用，arc","person类的构造函数的时候，"john","person结构体含有一个名为fullnam","peter","pi","piec","pink","pixel","place","plai","plane","planet","planet.earth","planet.earth.toraw","planet.fromraw(7","planet.fromraw(9)语句获得一个可选planet，如果可选planet可以被获得，把someplanet设置成该可选planet的内容。在这个范例中，无法检索到位置为9的行星，所以els","planet.fromraw(positiontofind","planet.uranu","planet.venus的原始值是2","player","player(coin","player(nam","player.completedlevel(1","player.tracker.advancetolevel(6","playernam","playeron","playerone!.coinsinpurs","playerone!.wincoins(2_000","playerone变量设置为nil，意思是“没有player实例”。当这种情况发生的时候，playerone变量对player实例的引用被破坏了。没有其它属性或者变量引用play","playerone是可选的，所以由一个感叹号（!）来修饰，每当其wincoins方法被调用时，coinsinpurs","player实例存储在一个名为playerone的可选play","player类使用leveltrack","player类创建一个新的leveltracker实例来监测这个用户的发展进度。他提供了completedlevel方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了advancetolevel返回的布尔值，因为之前调用leveltracker.unlocklevel","player类定义了一个wincoins方法，该方法从银行获取一定数量的硬币，并把它们添加到玩家的钱包。player类还实现了一个析构函数，这个析构函数在play","pleas","plu","plusminusvector","plusthre","pm","point","point(x","point.0","point.1","pointonefouronefivenin","point封装了一个(x","point来引用元组(int","point来表示square的中心点。如代码所示，它正确返回了中心点(5","point结构体定义了一个变异方法（mut","point（x","pop","pop并移除值"cuatro"","pop方法的返回值，该返回值将是一个t","posit","positiontofind","possibl","possibleinteg","possibleintegervalu","possiblenumb","possiblenumber.toint","possiblenumber.toint返回的可选int包含一个值，创建一个叫做actualnumb","possibleplanet","possiblestr","postfix","postfix-express","postfix-expression­.­decimal-digit","postfix-expression­.­dynamictyp","postfix-expression­.­identifier­generic-argument-clause(opt","postfix-expression­.­init","postfix-expression­.­self","postfix-expression­[­expression-list","postfix-expression­parenthesized-express","postfix-expression­parenthesized-expression­(opt)­trailing-closur","postfix-expression­postfix-oper","postfix-oper","postfix-operator-declar","postfix-self-express","potentialoverflow","powder","power","pp-prog","pp-prog告诉我，这几天太累了，校对到一半睡着了，醒来又继续做。2点17","preced","precedence-claus","precedence-clause­opt­associativity-clause­opt","precedence-level","precedence­precedence-level","precedence并优先级(preced","prefix","prefix-express","prefix-expression­binary-expressions(opt","prefix-oper","prefix-operator-declar","prefix存在时，将prefix插入到name之前来为starship构建fullnam","prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（caus","preslei","prettytextrepresent","prettytextrepresentable协议的同时，也需要遵循textrepresent","prettytextrepresentable协议继承了textrepresent","primari","primary-express","prime","print","print(\"\\(codeunit","print(\"\\(scalar.valu","print(\"\\n","print(\"conson","print(\"oth","print(\"vowel","printandcount","printandcount(\"hello","printandcount(stringtoprint","printclassnam","printhelloworld","printletterkinds(\"hello","printletterkinds(word","printletterkinds的输入是一个string值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的kind计算属性，并打印出合适的类别描述。所以printletterkinds就可以用来打印一个完整单词中所有字母的类型，正如上述单词"hello"","println","println(\"'\\\\(word","println(\"(0","println(\"(\\(point.0","println(\"(\\(somepoint.0","println(\"(\\(x","println(\"3的6倍是\\(threetimestable[6","println(\"\\(airportcod","println(\"\\(animalname)","println(\"\\(bas","println(\"\\(country.name)'","println(\"\\(currentvalu","println(\"\\(index","println(\"\\(mansioncount","println(\"\\(nam","println(\"\\(possiblenumb","println(\"\\(scalar","println(\"\\(somecharact","println(\"\\(total.vowel","println(\"a","println(\"about","println(\"access","println(\"ad","println(\"airport","println(\"al","println(\"an","println(\"and","println(\"apart","println(\"area","println(\"automaticcar","println(\"b","println(\"bicycl","println(\"car","println(\"card","println(\"cinema","println(\"count","println(\"eww","println(\"gam","println(\"goodby","println(\"happi","println(\"hd","println(\"hello","println(\"here'","println(\"highest","println(\"i'm","println(\"index","println(\"it","println(\"it'","println(\"item","println(\"john'","println(\"level","println(\"lot","println(\"media","println(\"mmm","println(\"mostli","println(\"movi","println(\"not","println(\"on","println(\"play","println(\"playeron","println(\"qr","println(\"random","println(\"result","println(\"rol","println(\"som","println(\"somebaseclass","println(\"someint","println(\"somesubclass","println(\"someth","println(\"somewher","println(\"song","println(\"speedlimitedcar","println(\"square.origin","println(\"start","println(\"tandem","println(\"tentighti","println(\"th","println(\"that","println(\"theaceofspad","println(\"ther","println(\"thes","println(\"thi","println(\"thre","println(\"un","println(\"unusualmenageri","println(\"upc-a","println(\"watch","println(\"welcom","println(\"wher","println(\"zero","println(a[0","println(ages[\"pet","println(assumedstr","println(audiochannel.maxinputlevelforallchannel","println(b[0","println(board.squareisblackatrow(0","println(board.squareisblackatrow(9","println(c[0","println(cat","println(charact","println(counter.count","println(d12.astext","println(definitestr","println(descript","println(friendlywelcom","println(game.asprettytext","println(game.astext","println(halfopenrangelength(1","println(item","println(item.descript","println(leftchannel.currentlevel","println(manager.importer.filenam","println(messag","println(name[0","println(paragraph!.ashtml","println(possiblestr","println(puzzleoutput","println(rightchannel.currentlevel","println(sayhello(\"anna","println(sayhello(\"brian","println(sayhelloagain(\"anna","println(sayhelloworld","println(someclass.computedtypeproperti","println(somestructure.storedtypeproperti","println(somethingtextrepresentable.astext","println(stringtoprint","println(text","println(thing.astext","println(“th","println函数输出传入的str","println（\"somebaseclass","println（\"somesubclass","printmathresult","printmathresult(addtwoint","printmathresult(mathfunct","printnumberofroom","prints\"hello","printwithoutcount","printwithoutcounting(\"hello","printwithoutcounting(stringtoprint","print（parent!.titl","print（self!.titl","print（self.titl","privat","procotol","productbarcod","productbarcode的新变量，并且赋给它一个barcode.upca的实例元组值(8","productcod","properit","properti","properties）构造器（initializers）方法（methods）修改实例方法（mut","properties），方法（methods），构造过程（initialization），扩展（extensions）和协议（protocol","property)在实例方法中修改值类型(modifi","property)还是计算型属性(calcul","property)，也能够要求属性的(设置权限)sett","property）还是计算型属性（comput","property），后者则把area写为存储型属性（stor","property），或附属脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overrid","properyt","propetri","protocol","protocol<protocol","protocol<someprotocol","protocol-associated-type-declar","protocol-bodi","protocol-composition-typ","protocol-declar","protocol-identifi","protocol-identifier-list","protocol-initializer-declar","protocol-member-declar","protocol-member-declarations­opt","protocol-member-declaration­protocol-member-declarations­opt","protocol-method-declar","protocol-nam","protocol-property-declar","protocol-subscript-declar","protocol(item","repeatedvalu","repeatedvalue:0.0","repetit","repetitions(task","report","represent","requierd","requir","requirement-claus","requirement-list","requirement­,­requirement-list","reserv","reset","reset将计数器重置为0","resid","residence?属性，如果residence存在则取回numberofroom","residence中也提供了一个printnumberofroom","residence具有一个int类型的numberofroom","residence存储了一个room实例的数组，它的numberofrooms属性值不是一个固定的存储值，而是通过计算而来的。numberofrooms属性值是由返回rooms数组的count","residence定义了一个自判断属性叫address（address?）。address","residence实例给john.resid","residence实例给john.residence，且在他的rooms数组中有一个或多个room实例，那么你可以使用可选链通过residence子脚本来获取在room","residence属性numberofrooms属性值，将会引发运行时错误，因为这时没有可以供解析的resid","residence的printnumberofrooms方法会打印numberofroom","residence类中定义的子脚本来获取john.residence数组中第一个房间的名字。因为john.residence现在是nil","resolut","resolution()或videomod","resolution(width","resolution的结构体，用来描述一个显示器的像素分辨率。这个结构体包含了两个名为width和height的储存属性。储存属性是捆绑和储存在类或结构体中的常量或变量。当这两个属性被初始化为整数0的时候，它们会被推断为int","resolution结构体和videomode类的定义仅描述了什么是resolution和videomode。它们并没有描述一个特定的分辨率（resolution）或者视频模式（video","resolution（width:640","respond","respons","response声明为string?类型，或者说是可选字符串类型opt","result","result(str","result(sunris","retriev","return","return-stat","returnfifteen","returntyp","return时，仅仅是将控制权从该函数或方法传递给调用者，而不返回一个值。（这就是说，该函数或方法的返回类型为void","return语句后面带表达式时，表达式的值将会返回给调用者。如果表达式值的类型与调用者期望的类型不匹配，swift","return语句时，可以只写return这个关键词，也可以在return","return）\\r","return）或换行符（lin","return）（u+000d","revers","rh","rhsitem","rich","rick","ridlei","right","right-hand","right.i","right.x","rightchannel","rightchannel.currentlevel","rise","roll","roll方法用来模拟骰子的面值。它先使用generator的random方法来创建一个[0-1","romeoandjuliet","room","room(","room(nam","roomcount","rooms.count","rooms[i","rooms数组的room类是一个很简单的类，它只有一个name属性和一个设定room","rooms数组，resid","rooms，它被初始化为一个room","roraw获得，如exampleenum.b.toraw()。你也可以通过调用fromraw","row","row0","row1","rowheight","rowheight定义成变量，因为它的值无需在if","row和column的数量来构造一个新的matrix","row和column附属脚本的matrix","runingtotal变量的内存管理操作，如果不再被incrementor","runningtot","runningtotal增加amount","runningtotal的值，incrementor捕获了当前runningtotal变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeincrementor结束时候并不会消失，也保证了当下一次执行incrementor函数时，runningtot","runtim","s","s1","s2","s2)，backwards函数返回true，表示在新的数组中s1应该出现在s2","s2)，该表达式返回bool类型值，因此这里没有歧义，return","safe","same","same-type-requir","samequot","sampl","sandwich","sankesandladders的实例都可以使用asprettytext","saturn","saygoodby","saygoodbye(\"dav","saygoodbye(personnam","sayhello","sayhello(personnam","sayhelloagain(personnam","sayhelloworld","sayhello。上面的例子展示的是用"anna"和"brian"","scalar","scarf","scene","scene.hasprefix(\"act","scene.hassuffix(\"capulet'","scene.hassuffix(\"friar","score","scott","second","secondforloop","secondnumb","secondvector","see","self","self-express","self.anm","self.area","self.artist","self.blu","self.capitalc","self.column","self.count","self.countri","self.custom","self.gener","self.green","self.greet","self.init(nam","self.init(origin","self.init在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用self.init","self.init（initi","self.leg","self.memb","self.nam","self.name)>\\(text)(somet","someresolut","someresolution.width","someresolution.width引用someresolution的width属性，返回width的初始值0","somestr","somestring变量通过字符串字面量进行初始化，swift","somestructur","somestructure.storedtypeproperti","somestructure等），以便符合标准swift","somesubclass","somesuperclass","somesupertyp","someth","somethingtextrepresent","sometuple的类型被指定为(doubl","sometuple：(doubl","sometyp","sometype(ofinitialvalu","sometypemethod","sometypeproperti","someu","somevalu","somevalue是一个标识符模式，匹配了类型是int的42","somevehicl","somevideomod","somevideomode.resolution.width","somevideomode中resolution属性的width这个子属性，以上操作并不需要从新设置resolut","song","song(nam","song.artist","song.nam","songcount","songcount，用来计算数组librari","song检查item是否为song类型的实例。在循环结束后，moviecount","sorri","sort","sort([1","sort(nam","sort函数对一个str","sort函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回true，反之返回fals","sort函数的参数进行传入的，swift","sort函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于backward","sort函数的第二个参数函数类型明确了闭包必须返回一个bool","sort期望第二个参数是类型为(str","soup","south","space","space）（u+0020）、换行符（lin","spade","sparklingheart","specifi","speed","speedlimitedcar","speedlimitedcar实例的speed属性时，属性setter的实现会去检查新值与限制值40mph的大小，它会将超类的speed设置为newvalue和40.0中较小的那个。这两个值哪个较小由min函数决定，它是swift标准库中的一个全局函数。min","speedlimitedcar实例的speed属性设置为一个大于40mph的数，然后打印description函数的输出，你会发现速度被限制在40mph","speedlimitedcar，它是car的子类。类speedlimitedcar表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的spe","spici","spider","spread","spread"，"cheese"，和"butter"替换为"bananas"","squar","square(sidelength","square.cent","square.origin","square.origin.i","square.origin.x","square.sidelength","squareisblackatrow(row","square增加board[square]的值向前或向后移动（遇到了梯子或者蛇）之前，检测square的值是否小于board的count","square的center属性可以通过点运算符（square.cent","square的rect实例，初始值原点是(0","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/barcode_qr_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/barcode_upc_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/computedproperties_2x.png","src=\"https://developer.apple.com/library/prerelease/ios/documentation/swift/conceptual/swift_programming_language/art/staticpropertiesvumeter_2x.png","stack","stack(inout","swaptwovalues例子中，占位类型t是一种类型参数的示例。类型参数指定并命名为一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（如 Swift 中文翻译组：364279588（要求对翻译感兴趣）
 
-Swift 是苹果在 WWDC 2014 上发布的一款全新的编程语言，本书译自苹果官方的 Swift 教程《The Swift Programming Language》。
+> Swift 兴趣交流群：307017261
 
-翻译正在进行中，翻译完成的部分会实时同步到这里。您可以到[项目首页](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)查看当前进度。
+> [Swift 开发者社区](http://swiftist.org)
 
-由于是多人协同翻译，可能会有些术语或者句子翻译不太恰当，如果您在阅读过程中发现此类问题，请直接给我们提 issue 或者 pull request。翻译完成后我们会进行认真的校对，给大家提供一本高质量的 Swift 教程。
+
+> 如果你觉得这个项目不错，请[点击Star一下](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)，您的支持我们最大的动力。
 
-如果您愿意加入进来，帮助我们进行翻译和校对，请阅读[项目首页](https://github.com/numbbbbb/the-swift-programming-language-in-chinese)中的说明并加入QQ群：364279588，我们期待您的加入，在 Swift 的历史上留下您的足迹！
+# 这一次，让中国和世界同步
 
-最后，非常感谢您的阅读，如果您觉得本文不错的话请分享给其他人，您的支持就是我们最大的动力！
+现在是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
+- coverxit
+- wh1100717
+- TimothyYe
+- honghaoz
+- Hawstein
+- JaySurplus
+- stanzhai
+- lyuka
+- geek5nan
+- xielingwang
+- yankuangshi
+- dabing1022
+- siemenliu
+- fd5788
+- youkugems
+- haolloyin
+- superkam
+- vclwei
+- sg552
+- bzsy
+- pyanfield
+- ericzyh
+- 088haizi
+- viztor
+- pp-prog
+- baocaixiong
+- marsprince
+- shinyzhu
+- happyming
+- menlongsheng
+- zq54zquan
+- Evilcome
+- lslxdx
+- yeahdongcn
 
diff --git a/source/SUMMARY.md b/source/SUMMARY.md
index 8796bc54..c6648ad6 100644
--- a/source/SUMMARY.md
+++ b/source/SUMMARY.md
@@ -22,7 +22,7 @@
    * [自动引用计数](chapter2/16_Automatic_Reference_Counting.md)
    * [可选链](chapter2/17_Optional_Chaining.md)
    * [类型检查](chapter2/18_Type_Casting.md)
-   * [嵌套类型](chapter2/19_Nested_Types.md)
+   * [类型嵌套](chapter2/19_Nested_Types.md)
    * [扩展](chapter2/20_Extensions.md)
    * [协议](chapter2/21_Protocols.md)
    * [泛型](chapter2/22_Generics.md)
diff --git a/source/chapter1/01_swift.md b/source/chapter1/01_swift.md
index f87e6dff..06d402a9 100644
--- a/source/chapter1/01_swift.md
+++ b/source/chapter1/01_swift.md
@@ -1,14 +1,18 @@
+> 翻译：numbbbbb
+
+> 校对：yeahdongcn
+
 # 关于 Swift
 -----------------
 
-Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。Swift 结合了 C 和 Objective-C 的优点并且不受C的兼容性的限制。Swift 使用安全的编程模式并添加了很多新特性，这将使编程更简单，扩展性更强，也更有趣。除此之外，Swift 还支持人见人爱的 Cocoa 和 Cocoa Touch 框架。拥有了这些特性，Swift将重新定义软件开发。
+Swift 是一种新的编程语言，用于编写 iOS 和 OS X 应用。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 还有许多新特性并且支持过程式编程和面向对象编程。
+Objective-C 开发者对 Swift 并不会感到陌生。它采用了 Objective-C 的命名参数以及动态对象模型，可以无缝对接到现有的 Cocoa 框架，并且可以兼容 Objective-C 代码。在此基础之上，Swift 还有许多新特性并且支持过程式编程和面向对象编程。
 
 Swift 对于初学者来说也很友好。它是第一个既满足工业标准又像脚本语言一样充满表现力和趣味的编程语言。它支持代码预览，这个革命性的特性可以允许程序员在不编译和运行应用程序的前提下运行 Swift 代码并实时查看结果。
 
-Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 即可以用于开发“hello, world”这样的小程序，也可以用于开发一个完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。
+Swift 将现代编程语言的精华和苹果工程师文化的智慧结合了起来。编译器对性能进行了优化，编程语言对开发进行了优化，两者互不干扰，鱼与熊掌兼得。Swift 即可以用于开发“hello, world”这样的小程序，也可以用于开发一套完整的操作系统。所有的这些特性让 Swift 对于开发者和苹果来说都是一项值得的投资。
 
 用 Swift 编写 iOS 和 OS X 应用将是一场美妙的体验，Swift 之后也会不断开发新特性和兼容性。我们对 Swift 充满信心，你还在等什么！
diff --git a/source/chapter1/02_a_swift_tour.md b/source/chapter1/02_a_swift_tour.md
index 6cdbf500..f17eb5f6 100644
--- a/source/chapter1/02_a_swift_tour.md
+++ b/source/chapter1/02_a_swift_tour.md
@@ -1,15 +1,19 @@
+> 翻译：numbbbbb
+> 校对：shinyzhu
+
 # Swift 初见
------------------
+
+---
 
 本页内容包括：
 
--   简单值
--   控制流
--   函数和闭包
--   对象和类
--   枚举和结构体
--   接口和扩展
--   泛型
+-   [简单值（Simple Values）](#simple_values)
+-   [控制流（Control Flow）](#control_flow)
+-   [函数和闭包（Functions and Closures）](#functions_and_closures)
+-   [对象和类（Objects and Classes）](#objects_and_classes)
+-   [枚举和结构体（Enumerations and Structures）](#enumerations_and_structures)
+-   [接口和扩展（Protocols and Extensions）](#protocols_and_extensions)
+-   [泛型（Generics）](#generics)
 
 通常来说，编程语言教程中的第一个程序应该在屏幕上打印“Hello, world”。在 Swift 中，可以用一行代码实现：
 
@@ -19,11 +23,14 @@
 
 这个教程会通过一系列编程例子来让你对 Swift 有初步了解，如果你有什么不理解的地方也不用担心——任何本章介绍的内容都会在后面的章节中详细讲解。
 
-> 注意：为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。
+> 注意：
 
+> 为了获得最好的体验，在 Xcode 当中使用代码预览功能。代码预览功能可以让你编辑代码并实时看到运行结果。
+
+
 ## 简单值
 
-使用`let`来声明常量，使用`var`来声明变量。一个常量的值在编译时并不需要获取，但是你必须而且只能为它赋值一次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。
+使用`let`来声明常量，使用`var`来声明变量。一个常量的值在编译时并不需要获取，但是你只能为它赋值一次。也就是说你可以用常量来表示这样一个值：你只需要决定一次，但是需要使用很多次。
 
     var myVariable = 42
     myVariable = 50
@@ -37,7 +44,9 @@
     let implicitDouble = 70.0
     let explicitDouble: Double = 70
 
-> 练习：创建一个常量，显式指定类型为`Float`并指定初始值为4。
+> 练习：
+>
+> 创建一个常量，显式指定类型为`Float`并指定初始值为4。
 
 值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。
 
@@ -45,7 +54,9 @@
     let width = 94
     let widthLabel = label + String(width)
 
-> 练习：删除最后一行中的`String`，错误提示是什么？
+> 练习：
+>
+> 删除最后一行中的`String`，错误提示是什么？
 
 有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。例如：
 
@@ -54,7 +65,9 @@
     let appleSummary = "I have \(apples) apples."
     let fruitSummary = "I have \(apples + oranges) pieces of fruit."
 
-> 练习：使用`\()`来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。
+> 练习：
+>
+> 使用`\()`来把一个浮点计算转换成字符串，并加上某人的名字，和他打个招呼。
 
 使用方括号`[]`来创建数组和字典，并使用下标或者键（key）来访问元素。
 
@@ -76,6 +89,7 @@
 
     shoppingList = []   // 去逛街并买点东西
 
+
 ## 控制流
 
 使用`if`和`switch`来进行条件操作，使用`for-in`、`for`、`while`和`do-while`来进行循环。包裹条件和循环变量括号可以省略，但是语句体的大括号是必须的。
@@ -104,7 +118,9 @@
         greeting = "Hello, \(name)"
     }
 
-> 练习：把`optionalName`改成`nil`，greeting会是什么？添加一个`else`语句，当`optionalName`是`nil`时给greeting赋一个不同的值。
+> 练习：
+>
+> 把`optionalName`改成`nil`，greeting会是什么？添加一个`else`语句，当`optionalName`是`nil`时给greeting赋一个不同的值。
 
 如果变量的可选值是`nil`，条件会判断为`false`，大括号中的代码会被跳过。如果不是`nil`，会将值赋给`let`后面的常量，这样代码块中就可以使用这个值了。
 
@@ -122,7 +138,9 @@
         let vegetableComment = "Everything tastes good in soup."
     }
 
-> 练习：删除`default`语句，看看会有什么错误？
+> 练习：
+>
+> 删除`default`语句，看看会有什么错误？
 
 运行`switch`中匹配到的子句之后，程序会退出`switch`语句，并不会继续向下运行，所以不需要在每个子句结尾写`break`。
 
@@ -143,7 +161,9 @@
     }
     largest
 
-> 练习：添加另一个变量来记录哪种类型的数字是最大的。
+> 练习：
+>
+> 添加另一个变量来记录哪种类型的数字是最大的。
 
 使用`while`来重复运行一段代码直到不满足条件。循环条件可以在开头也可以在结尾。
 
@@ -175,6 +195,7 @@
 
 使用`..`创建的范围不包含上界，如果想包含的话需要使用`...`。
 
+
 ## 函数和闭包
 
 使用`func`来声明一个函数，使用名字和参数来调用函数。使用`->`来指定函数返回值。
@@ -184,7 +205,9 @@
     }
     greet("Bob", "Tuesday")
 
-> 练习：删除`day`参数，添加一个参数来表示今天吃了什么午饭。
+> 练习：
+>
+> 删除`day`参数，添加一个参数来表示今天吃了什么午饭。
 
 使用一个元组来返回多个值。
 
@@ -205,7 +228,9 @@
     sumOf()
     sumOf(42, 597, 12)
 
-> 练习：写一个计算参数平均值的函数。
+> 练习：
+>
+> 写一个计算参数平均值的函数。
 
 函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。
 
@@ -246,7 +271,7 @@
     var numbers = [20, 19, 7, 12]
     hasAnyMatches(numbers, lessThanTen)
 
-函数实际上是一种特殊的闭包，你可以使用`{}`来创建一个匿名闭包。使用`in`来分割参数、返回值与执行体。
+函数实际上是一种特殊的闭包，你可以使用`{}`来创建一个匿名闭包。使用`in`来分割参数并返回类型。
 
     numbers.map({
         (number: Int) -> Int in
@@ -254,7 +279,9 @@
         return result
         })
 
-> 练习：重写闭包，对所有奇数返回0.
+> 练习：
+>
+> 重写闭包，对所有奇数返回 0.
 
 有很多种创建闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
 
@@ -262,6 +289,7 @@
 
     sort([1, 5, 3, 12, 2]) { $0 > $1 }
 
+
 ## 对象和类
 
 使用`class`和类名来创建一个类。类中属性的声明和常量、变量声明一样，唯一的区别就是它们的上下文是类。同样，方法和函数声明也一样。
@@ -273,7 +301,9 @@
         }
     }
 
-> 练习：使用`let`添加一个常量属性，再添加一个接收一个参数的方法。
+> 练习：
+>
+> 使用`let`添加一个常量属性，再添加一个接收一个参数的方法。
 
 要创建一个类的实例，在类名后面加上括号。使用点语法来访问实例的属性和方法。
 
@@ -325,7 +355,9 @@
     test.area()
     test.simpleDescription()
 
-> 练习：创建`NamedShape`的另一个子类`Circle`，构造器接收两个参数，一个是半径一个是名称，实现`area`和`describe`方法。
+> 练习：
+>
+> 创建`NamedShape`的另一个子类`Circle`，构造器接收两个参数，一个是半径一个是名称，实现`area`和`describe`方法。
 
 属性可以有 getter 和 setter 。
 
@@ -406,7 +438,7 @@
     let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
     let sideLength = optionalSquare?.sideLength
 
-
+
 ## 枚举和结构体
 
 使用`enum`来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法。
@@ -433,7 +465,9 @@
     let ace = Rank.Ace
     let aceRawValue = ace.toRaw()
 
-> 练习：写一个函数，通过比较它们的原始值来比较两个`Rank`值。
+> 练习：
+>
+> 写一个函数，通过比较它们的原始值来比较两个`Rank`值。
 
 在上面的例子中，枚举原始值的类型是`Int`，所以你只需要设置第一个原始值。剩下的原始值会按照顺序赋值。你也可以使用字符串或者浮点数作为枚举的原始值。
 
@@ -464,7 +498,9 @@
     let hearts = Suit.Hearts
     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`。已知变量类型的情况下你可以使用缩写。
 
@@ -482,7 +518,9 @@
     let threeOfSpades = Card(rank: .Three, suit: .Spades)
     let threeOfSpadesDescription = threeOfSpades.simpleDescription()
 
-> 练习：给`Card`添加一个方法，创建一副完整的扑克牌并把每张牌的rank和suit对应起来。
+> 练习：
+>
+> 给`Card`添加一个方法，创建一副完整的扑克牌并把每张牌的 rank 和 suit 对应起来。
 
 一个枚举成员的实例可以有实例值。相同枚举成员的实例可以有不同的值。创建实例的时候传入值即可。实例值和原始值是不同的：枚举成员的原始值对于所有实例都是相同的，而且你是在定义枚举的时候设置原始值。
 
@@ -503,10 +541,13 @@
         let serverResponse = "Failure...  \(error)"
     }
 
-> 练习：给`ServerResponse`和`switch`添加第三种情况。
+> 练习：
+>
+> 给`ServerResponse`和`switch`添加第三种情况。
 
 注意如何从`ServerResponse`中提取日升和日落时间。
 
+
 ## 接口和扩展
 
 使用`protocol`来声明一个接口。
@@ -539,7 +580,9 @@
     b.adjust()
     let bDescription = b.simpleDescription
 
-> 练习：写一个实现这个接口的枚举。
+> 练习：
+>
+> 写一个实现这个接口的枚举。
 
 注意声明`SimpleStructure`时候`mutating`关键字用来标记一个会修改结构体的方法。`SimpleClass`的声明不需要标记任何方法因为类中的方法经常会修改类。
 
@@ -555,7 +598,9 @@
     }
     7.simpleDescription
 
-> 练习：给`Double`类型写一个扩展，添加`absoluteValue`功能。
+> 练习：
+>
+> 给`Double`类型写一个扩展，添加`absoluteValue`功能。
 
 你可以像使用其他命名类型一样使用接口名——例如，创建一个有不同类型但是都实现一个接口的对象集合。当你处理类型是接口的值时，接口外定义的方法不可用。
 
@@ -565,6 +610,7 @@
 
 即使`protocolValue`变量运行时的类型是`simpleClass`，编译器会把它的类型当做`ExampleProtocol`。这表示你不能调用类在它实现的接口之外实现的方法或者属性。
 
+
 ## 泛型
 
 在尖括号里写一个名字来创建一个泛型函数或者类型。
@@ -602,6 +648,8 @@
     }
     anyCommonElements([1, 2, 3], [3])
 
-> 练习：修改`anyCommonElements`函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
+> 练习：
+>
+> 修改`anyCommonElements`函数来创建一个函数，返回一个数组，内容是两个序列的共有元素。
 
 简单起见，你可以忽略`where`，只在冒号后面写接口或者类名。` `和``是等价的。
diff --git a/source/chapter2/01_The_Basics.md b/source/chapter2/01_The_Basics.md
index 1a65cb85..eb9f2792 100644
--- a/source/chapter2/01_The_Basics.md
+++ b/source/chapter2/01_The_Basics.md
@@ -1,9 +1,29 @@
+> 翻译：numbbbbb, lyuka, JaySurplus
+
+> 校对：lslxdx
+
 # 基础部分
 -----------------
 
+本页包含内容：
+
+- [常量和变量](#constants_and_variables)
+- [注释](#comments)
+- [分号](#semicolons)
+- [整数](#integers)
+- [浮点数](#floating-point_numbers)
+- [类型安全和类型推测](#type_safety_and_type_inference)
+- [数值型字面量](#numeric_literals)
+- [数值型类型转换](#numeric_type_conversion)
+- [类型别名](#type_aliases)
+- [布尔值](#booleans)
+- [元组](#tuples)
+- [可选](#optionals)
+- [断言](#assertions)
+
 Swift 是 iOS 和 OS X 应用开发的一门新语言。然而，如果你有 C 或者 Objective-C 开发经验的话，你会发现 Swift 的很多内容都是你熟悉的。
 
-Swift 的类型是在 C 和 Objective-C 的基础上提出的，`Int`是整型；`Double`和`Float`是浮点型；`Bool`是布尔型；`String`是字符串。Swift 还有两个有用的集合类型，`Array`和`Dictionary`，详情参见`集合类型(待添加链接)`。
+Swift 的类型是在 C 和 Objective-C 的基础上提出的，`Int`是整型；`Double`和`Float`是浮点型；`Bool`是布尔型；`String`是字符串。Swift 还有两个有用的集合类型，`Array`和`Dictionary`，请参考[集合类型](04_Collection_Types.html)。
 
 就像 C 语言一样，Swift 使用变量来进行存储并通过变量名来关联值。在 Swift 中，值不可变的变量有着广泛的应用，它们就是常量，而且比 C 语言的常量更强大。在 Swift 中，如果你要处理的值不需要改变，那使用常量可以让你的代码更加安全并且更好地表达你的意图。
 
@@ -13,9 +33,10 @@ Swift 还增加了可选（Optional）类型，用于处理值缺失的情况。
 
 Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift 可以让你清楚地知道值的类型。如果你的代码期望得到一个`String`，类型安全会阻止你不小心传入一个`Int`。你可以在开发阶段尽早发现并修正错误。
 
+
 ## 常量和变量
 
-常量和变量把一个名字（比如`maximumNumberOfLoginAttempts`或者`welcomeMessage`）和一个指定类型的值（比如数字`10`或者字符串`Hello`）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。
+常量和变量把一个名字（比如`maximumNumberOfLoginAttempts`或者`welcomeMessage`）和一个指定类型的值（比如数字`10`或者字符串`"Hello"`）关联起来。常量的值一旦设定就不能改变，而变量的值可以随意更改。
 
 ### 声明常量和变量
 
@@ -24,9 +45,9 @@ Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift
     let maximumNumberOfLoginAttempts = 10
     var currentLoginAttempt = 0
 
-这两行代码可以被理解为
-：
-“声明一个名字是`maximumNumberOfLoginAttempts`的新常量，并给它一个值`10`。然后，声明一个名字是`currentLoginAttempt`的变量并将它的值初始化为0.”
+这两行代码可以被理解为：
+
+“声明一个名字是`maximumNumberOfLoginAttempts`的新常量，并给它一个值`10`。然后，声明一个名字是`currentLoginAttempt`的变量并将它的值初始化为`0`.”
 
 在这个例子中，允许的最大尝试登录次数被声明为一个常量，因为这个值不会改变。当前尝试登录次数被声明为一个变量，因为每次尝试登录失败的时候都需要增加这个值。
 
@@ -34,17 +55,19 @@ Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift
 
     var x = 0.0, y = 0.0, z = 0.0
 
-> 注意：如果你的代码中有不需要改变的值，请将它声明为常量。只将需要改变的值声明为变量。
+>注意：
+>
+如果你的代码中有不需要改变的值，请使用`let`关键字将它声明为常量。只将需要改变的值声明为变量。
 
 ### 类型标注
 
-当你声明常量或者变量的时候可以加上类型标注，说明常量或者变量中要存储的值的类型。如果要添加类型标注，在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
+当你声明常量或者变量的时候可以加上_类型标注(type annotation)_，说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
 
 这个例子给`welcomeMessage`变量添加了类型标注，表示这个变量可以存储`String`类型的值：
 
     var welcomeMessage: String
 
-声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：：
+声明中的冒号代表着“是...类型”，所以这行代码可以被理解为：
 
 “声明一个类型为`String`，名字为`welcomeMessage`的变量。”
 
@@ -54,89 +77,97 @@ Swift 是一个类型安全的语言，可选就是一个很好的例子。Swift
 
     welcomeMessage = "Hello"
 
-> 注意：一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，详情参见`类型安全和类型推断(待添加链接)`。在上面的例子中，没有给`welcomeMessage`赋初始值，所以添加了一个类型标注。
+> 注意：
+>
+一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考[类型安全和类型推断](#type_safety_and_type_inference)。在上面的例子中，没有给`welcomeMessage`赋初始值，所以变量`welcomeMessage`的类型是通过一个类型标注指定的，而不是通过初始值推断的。
 
 ### 常量和变量的命名
 
-你可以用任何你喜欢的字符作为常量和变量名，包括Unicode字符：
+你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符：
 
     let π = 3.14159
     let 你好 = "你好世界"
     let 🐶🐮 = "dogcow"
 
-常量与变量名不能包含数学符号，箭头，保留的(或者非法的)Unicode码位，连线与制表符。尽管常量与变量名中可以包含数字，但是它们不能以数字打头。
+常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符。也不能以数字开头，但是可以在常量与变量名的其他地方包含数字。
 
-一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者以改变其存储的值为其他类型。同时，你也不能将常量与变量进行互转。
+一旦你将常量或者变量声明为确定的类型，你就不能使用相同的名字再次进行声明，或者改变其存储的值的类型。同时，你也不能将常量与变量进行互转。
 
-> 注意：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号(`)将关键字围住的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。
+> 注意：
+>
+如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。
 
 你可以更改现有的变量值为其他同类型的值，在下面的例子中，`friendlyWelcome`的值从`"Hello!"`改为了`"Bonjour!"`:
 
     var friendlyWelcome = "Hello!"
     friendlyWelcome = "Bonjour!"
-    // friendlyWelcome is now "Bonjour!"
+    // friendlyWelcome 现在是 "Bonjour!"
 
-和变量不一样，常量的值一旦被确定以后就不能更改了。尝试这样做会在编译时报错：
+与变量不同，常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错：
 
     let languageName = "Swift"
     languageName = "Swift++"
-    // this is a compile-time error - languageName cannot be changed
+    // 这会报编译时错误 - languageName 不可改变
 
 ### 输出常量和变量
 
 你可以用`println`函数来输出当前常量或变量的值:
 
     println(friendlyWelcome)
-    // prints "Bonjour!"
+    // 输出 "Bonjour!"
 
-`println`是一个用来输出的全局函数，输出的内容会在最后带换行。如果你用Xcode，`println`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会加入换行。)
+`println`是一个用来输出的全局函数，输出的内容会在最后换行。如果你用 Xcode，`println`将会输出内容到“console”面板上。(另一种函数叫`print`，唯一区别是在输出内容最后不会换行。)
 
 `println`函数输出传入的`String`值：
 
     println("This is a string")
-    // prints "This is a string"
+    // 输出 "This is a string"
 
-像Cocoa里的`NSLog`函数一样，`println`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
+与 Cocoa 里的`NSLog`函数类似的是，`println`函数可以输出更复杂的信息。这些信息可以包含当前常量和变量的值。
 
-Swift用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift会用当前常量或变量的值替换这些占位符。将常量或变量名放入反斜杠符加一对圆括号中`"\()"`：
+Swift 用_字符串插值（string interpolation）_的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义：
 
     println("The current value of friendlyWelcome is \(friendlyWelcome)")
-    // prints "The current value of friendlyWelcome is Bonjour!
+    // 输出 "The current value of friendlyWelcome is Bonjour!
 
-> 注意：字符串插值所有可用的选项在 字符串插值 这章中讲述。
+> 注意：
+>
+字符串插值所有可用的选项，请参考[字符串插值](03_Strings_and_Characters.html#string_interpolation)。
 
-### 注释
+
+## 注释
 请将你的代码中的非执行文本注释成提示或者笔记以方便你将来阅读。Swift 的编译器将会在编译代码时自动忽略掉注释部分。
 
-Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠作(//)为起始标记:
+Swift 中的注释与C 语言的注释非常相似。单行注释以双正斜杠作(`//`)为起始标记:
 
-    // this is a comment
+    // 这是一个注释
 
-你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(/\*)，终止标记为一个星号后跟随单个正斜杠(\*/):
+你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(`/*`)，终止标记为一个星号后跟随单个正斜杠(`*/`):
 
-    /* this is also a comment,
-    but written over multiple lines */
+    /* 这是一个,
+    多行注释 */
 
-与C 语言多行注释不同的是，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：
+与C 语言多行注释不同，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：
 
-    /* this is the start of the first multiline comment
-    /* this is the second, nested multiline comment */
-    this is the end of the first multiline comment */
+    /* 这是第一个多行注释的开头
+    /* 这是第二个被嵌套的多行注释 */
+    这是第一个多行注释的结尾 */
 
 通过运用嵌套多行注释，你可以快速方便的注释掉一大段代码，即使这段代码之中已经含有了多行注释块。
 
+
 ## 分号
-与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号(;)，当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句:
+与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（`;`），当然，你也可以按照你自己的习惯添加分号。有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句：
 
     let cat = "🐱"; println(cat)
-    // prints "🐱"
-
+    // 输出 "🐱"
 
+
 ## 整数
 
-整数就是没有小数部分的数字，比如`42`和`-23`。整数可以是有符号（正、负、零）或者无符号（正、零）。
+整数就是没有小数部分的数字，比如`42`和`-23`。整数可以是`有符号`（正、负、零）或者`无符号`（正、零）。
 
-Swift 提供了8、16、32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是`UInt8`，32位有符号整数类型是`Int32`。就像 Swift 的其他类型一样，整数类型采用大写命名法。
+Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是`UInt8`，32位有符号整数类型是`Int32`。就像 Swift 的其他类型一样，整数类型采用大写命名法。
 
 ### 整数范围
 
@@ -161,8 +192,11 @@ Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台
 * 在32位平台上，`UInt`和`UInt32`长度相同。
 * 在64位平台上，`UInt`和`UInt64`长度相同。
 
-> 注意：尽量不要使用`UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用`Int`，即使你要存储的值已知是非负的。统一使用`Int`可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，详情参见[类型安全和类型推测](## 类型安全和类型推测)。
+> 注意：
+>
+尽量不要使用`UInt`，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用`Int`，即使你要存储的值已知是非负的。统一使用`Int`可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，请参考[类型安全和类型推测](#type_safety_and_type_inference)。
 
+
 ## 浮点数
 
 浮点数是有小数部分的数字，比如`3.14159`，`0.1`和`-273.15`。
@@ -172,26 +206,29 @@ Swift 也提供了一个特殊的无符号类型`UInt`，长度与当前平台
 * `Double`表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
 * `Float`表示32位浮点数。精度要求不高的话可以使用此类型。
 
-> 注意：`Double`精确度很高，至少有15位数字，而`Float`最少只有6位数字。选择哪个类型取决于你的代码需要处理的数字大小。
+> 注意：
+>
+`Double`精确度很高，至少有15位数字，而`Float`最少只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围。
 
+
 ## 类型安全和类型推测
 
-Swift 是一个类型安全的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
+Swift 是一个_类型安全(type safe )_的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个`String`，你绝对不可能不小心传进去一个`Int`。
 
-Swift 是类型安全的，会在编译你的代码时进行类型检查，如果遇到不匹配的类型会报错。这可以让你在开发的时候尽早发现并修复错误。
+由于 Swift 是类型安全的，所以它会在编译你的代码时进行_类型检查(type checks)_，并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
 
-当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推测来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，判断你赋的值即可。
+当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用_类型推测(type inference)_来选择合适的类型。有了类型推测，编译器可以在编译代码的时候自动推测出表达式的类型。原理很简单，只要检查你赋的值即可。
 
-因为有类型推测，和 C 或者 Objc 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
+因为有类型推测，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
 
-当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个原始值即可触发类型推测。（原始值就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
+当你声明常量或者变量并赋初值的时候类型推测非常有用。当你在声明常量或者变量的时候赋给它们一个_字面量(literal value 或 literal)_即可触发类型推测。（字面量就是会直接出现在你代码中的值，比如`42`和`3.14159`。）
 
-举个例子，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推测出常量类型是`Int`，因为你给它赋的初值看起来很像一个整数：
+例如，如果你给一个新常量赋值`42`并且没有标明类型，Swift 可以推测出常量类型是`Int`，因为你给它赋的初始值看起来像一个整数：
 
     let meaningOfLife = 42
     // meaningOfLife 会被推测为 Int 类型
 
-同理，如果你没有给浮点原始值标明类型，Swift 会推测你想要的是`Double`：
+同理，如果你没有给浮点字面量标明类型，Swift 会推测你想要的是`Double`：
 
     let pi = 3.14159
     // pi 会被推测为 Double 类型
@@ -203,71 +240,73 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
     let anotherPi = 3 + 0.14159
     // anotherPi 会被推测为 Double 类型
 
-原始值`3`没有显式声明类型，而表达式中出现了一个浮点原始值，所以表达式会被推测为`Double`类型。
+原始值`3`没有显式声明类型，而表达式中出现了一个浮点字面量，所以表达式会被推测为`Double`类型。
 
-## 数值类原始值
+
+## 数值型字面量
 
-整数原始值可以被写作：
+整数字面量可以被写作：
 
 * 一个十进制数，没有前缀
 * 一个二进制数，前缀是`0b`
 * 一个八进制数，前缀是`0o`
 * 一个十六进制数，前缀是`0x`
 
-下面的所有整数原始值的十进制值都是`17`:
+下面的所有整数字面量的十进制值都是`17`:
 
     let decimalInteger = 17
     let binaryInteger = 0b10001       // 二进制的17
     let octalInteger = 0o21           // 八进制的17
-    let hexadecimalInteger = 0x11     // 十六机制的17
+    let hexadecimalInteger = 0x11     // 十六进制的17
 
-浮点原始值可以是十进制（没有前缀）或者是十六进制（前缀是`0x`）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点原始值还有一个可选的指数，在十进制浮点数中通过大写或者小写的`e`来指定，在十六进制浮点数中通过大写或者小写的`p`来指定。
+浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是`0x`）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。浮点字面量还有一个可选的_指数(exponent)_，在十进制浮点数中通过大写或者小写的`e`来指定，在十六进制浮点数中通过大写或者小写的`p`来指定。
 
-如果一个十进制数的指数为`exp`，那这个数相当于基数和10^exp的乘积：
-* 1.25e2 表示 1.25 × 10^2，等于 125.0。
-* 1.25e-2 表示 1.25 × 10^-2，等于 0.0125。
+如果一个十进制数的指数为`exp`，那这个数相当于基数和$10^{exp}$的乘积：
+* `1.25e2` 表示 $1.25 × 10^{2}$，等于 `125.0`。
+* `1.25e-2` 表示 $1.25 × 10^{-2}$，等于 `0.0125`。
 
-如果一个十六进制数的指数为`exp`，那这个数相当于基数和2^exp的乘积：
-* 0xFp2 表示 15 × 2^2，等于 60.0。
-* 0xFp-2 表示 15 × 2^-2，等于 3.75。
+如果一个十六进制数的指数为`exp`，那这个数相当于基数和$2^{exp}$的乘积：
+* `0xFp2` 表示 $15 × 2^{2}$，等于 `60.0`。
+* `0xFp-2` 表示 $15 × 2^{-2}$，等于 `3.75`。
 
-下面的这些浮点原始值都等于十进制的`12.1875`：
+下面的这些浮点字面量都等于十进制的`12.1875`：
 
     let decimalDouble = 12.1875
     let exponentDouble = 1.21875e1
     let hexadecimalDouble = 0xC.3p0
 
-数值类原始值可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响原始值：
+数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：
 
     let paddedDouble = 000123.456
     let oneMillion = 1_000_000
     let justOverOneMillion = 1_000_000.000_000_1
 
-## 数值类型转换
+
+## 数值型类型转换
 
-通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类原始值的类型推测。
+通常来讲，即使代码中的整数常量和变量已知非负，也请使用`Int`类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推测。
 只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。
 
 ### 整数转换
 
-不同整数类型的变量和常量可以存储不同大小的数字。`Int8`类型的常量或者变量可以存储的数字范围是`-128`~`127`，`UInt8`类型的常量或者变量能存储的数字范围是`0`~`255`。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
+不同整数类型的变量和常量可以存储不同范围的数字。`Int8`类型的常量或者变量可以存储的数字范围是`-128`~`127`，而`UInt8`类型的常量或者变量能存储的数字范围是`0`~`255`。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：
 
     let cannotBeNegative: UInt8 = -1
     // UInt8 类型不能存储负数，所以会报错
     let tooBig: Int8 = Int8.max + 1
     // Int8 类型不能存储超过最大值的数，所以会报错
 
-因为每一个整数类型都可以存储不同范围的值，你必须根据情况来选择不同的转换方法。不同的转换方法可以暴露出隐藏的转换错误并让你的代码更加清晰。
+由于每中整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。
 
-要将一种数字类型转换成另一种，你要用当前值来初始化一个新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量`twoThousand`类型是`UInt16`，然而常量`one`类型是`Uint8`。它们不能直接相加，因为它们类型不同。所以要调用`UInt16(one)`来创建一个新的`UInt16`数字并用`one`的值来初始化，然后使用这个新数字来计算：
+要将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量`twoThousand`是`UInt16`类型，然而常量`one`是`Uint8`类型。它们不能直接相加，因为它们类型不同。所以要调用`UInt16(one)`来创建一个新的`UInt16`数字并用`one`的值来初始化，然后使用这个新数字来计算：
 
     let twoThousand: UInt16 = 2_000
     let one: UInt8 = 1
     let twoThousandAndOne = twoThousand + UInt16(one)
 
-现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推测为`UInt16`，因为它是两个`UInt16`值的合。
+现在两个数字的类型都是`UInt16`，可以进行相加。目标常量`twoThousandAndOne`的类型被推测为`UInt16`，因为它是两个`UInt16`值的和。
 
-`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），详情参见`扩展(链接待添加)`.
+`SomeType(ofInitialValue)`是调用 Swift 构造器并传入一个初始值的默认方法。在语言内部，`UInt16`有一个构造器，可以接受一个`UInt8`类型的值，所以这个构造器可以用现有的`UInt8`来创建一个新的`UInt16`。注意，你并不能传入任意类型的值，只能传入`UInt16`内部有对应构造器的值。不过你可以扩展现有的类型来让它可以接收其他类型的值（包括自定义类型），请参考[扩展](20_Extensions.html)。
 
 ### 整数和浮点数转换
 
@@ -280,18 +319,21 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
 
 这个例子中，常量`three`的值被用来创建一个`Double`类型的值，所以加号两边的数类型相同。如果不进行转换，两者无法相加。
 
-浮点数转换为整数也一样，整数类型可以用`Double`或者`Float`类型来初始化：
+浮点数到整数的反向转换同样行，整数类型可以用`Double`或者`Float`类型来初始化：
 
     let integerPi = Int(pi)
     // integerPi 等于 3，所以被推测为 Int 类型
 
 当用这种方式来初始化一个新的整数值时，浮点值会被截断。也就是说`4.75`会变成`4`，`-3.9`会变成`-3`。
 
-> 注意：结合数字类常量和变量不同于结合数字类原始值。原始值`3`可以直接和原始值`0.14159`相加，因为数字原始值本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。
+> 注意：
+>
+结合数字类常量和变量不同于结合数字类字面量。字面量`3`可以直接和字面量`0.14159`相加，因为数字字面量本身没有明确的类型。它们的类型只在编译器需要求值的时候被推测。
 
+
 ## 类型别名
 
-类型别名就是给现有类型定义一个可选名字。你可以使用`typealias`关键字来定义类型别名。
+_类型别名(type aliases)_就是给现有类型定义另一个名字。你可以使用`typealias`关键字来定义类型别名。
 
 当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。假设你正在处理特定长度的外部资源的数据：
 
@@ -304,14 +346,15 @@ Swift 是类型安全的，会在编译你的代码时进行类型检查，如
 
 本例中，`AudioSample`被定义为`UInt16`的一个别名。因为它是别名，`AudioSample.min`实际上是`UInt16.min`，所以会给`maxAmplitudeFound`赋一个初值`0`。
 
+
 ## 布尔值
 
-Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
+Swift 有一个基本的_布尔(Boolean)_类型，叫做`Bool`。布尔值指_逻辑上的(logical)_，因为它们只能是真或者假。Swift 有两个布尔常量，`true`和`false`：
 
     let orangesAreOrange = true
     let turnipsAreDelicious = false
 
-`orangesAreOrange`和`turnipsAreDelicious`的类型会被推测为`Bool`，因为它们的初值是布尔原始值。就像之前提到的`Int`和`Double`一样，如果你创建变量的时候给它们赋值`true`或者`false`，那你不需要给常量或者变量标明`Bool`类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推测，这让 Swift 代码更加简洁并且可读性更高。
+`orangesAreOrange`和`turnipsAreDelicious`的类型会被推测为`Bool`，因为它们的初值是布尔字面量。就像之前提到的`Int`和`Double`一样，如果你创建变量的时候给它们赋值`true`或者`false`，那你不需要将常量或者变量声明为`Bool`类型。初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推测，这让 Swift 代码更加简洁并且可读性更高。
 
 当你编写条件语句比如`if`语句的时候，布尔值非常有用：
 
@@ -322,7 +365,7 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     }
     // 输出 "Eww, turnips are horrible."
 
-条件语句比如`if`语句的详细介绍参见`控制流(待添加链接)`。
+条件语句，例如`if`，请参考[控制流](05_Control_Flow.html)。
 
 如果你在需要使用`Bool`类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：
 
@@ -338,24 +381,25 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
         // 这个例子会编译成功
     }
 
-`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较会在`基本操作符(待添加链接)`中详细讨论。
+`i == 1`的比较结果是`Bool`类型，所以第二个例子可以通过类型检查。类似`i == 1`这样的比较，请参考[基本操作符](05_Control_Flow.html)。
 
-和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的作用总是在意料之中。
+和 Swift 中的其他类型安全的例子一样，这个方法可以避免错误并保证这块代码的意图总是清晰的。
 
+
 ## 元组
 
-元组把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。
+_元组（tuples）_把多个值组合成一个复合值。元组内的值可以使任意类型，并不要求是相同类型。
 
-下面这个例子中，`(404, "Not Found")`是一个描述 HTTP 状态码的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个`404 Not Found`状态码。
+下面这个例子中，`(404, "Not Found")`是一个描述 _HTTP 状态码（HTTP status code）_的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特殊值。如果你请求的网页不存在就会返回一个`404 Not Found`状态码。
 
     let http404Error = (404, "Not Found")
     // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")
 
-`(404, "Not Found")`元组把一个`Int`值和一个`String`值组合起来表示 HTTP 状态码的两个部分：一个数字和一个可以读懂的描述。这个元组可以被描述为“一个类型为`(Int, String)`的元组”。
+`(404, "Not Found")`元组把一个`Int`值和一个`String`值组合起来表示 HTTP 状态码的两个部分：一个数字和一个人类可读的描述。这个元组可以被描述为“一个类型为`(Int, String)`的元组”。
 
-你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为`(Int, Int, Int)`或者`(String, Bool)`或者包含其他类型的元组。
+你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。只要你想，你可以创建一个类型为`(Int, Int, Int)`或者`(String, Bool)`或者其他任何你想要的组合的元组。
 
-你可以将一个元组的内容分解成单独的常量和变量，然后你就可以正常使用它们了：
+你可以将一个元组的内容_分解（decompose）_成单独的常量和变量，然后你就可以正常使用它们了：
 
     let (statusCode, statusMessage) = http404Error
     println("The status code is \(statusCode)")
@@ -363,7 +407,7 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     println("The status message is \(statusMessage)")
     // 输出 "The status message is Not Found"
 
-如果你只需要一部分元组值，分解的时候可以把要忽略的部分设置成`_`：
+如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（`_`）标记：
 
     let (justTheStatusCode, _) = http404Error
     println("The status code is \(justTheStatusCode)")
@@ -387,21 +431,26 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     println("The status message is \(http200Status.description)")
     // 输出 "The status message is OK"
 
-作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。详情参见`返回多个值的函数(待添加链接)`。
+作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个`(Int, String)`元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。请参考[函数参数与返回值(06_Functions.html#Function_Parameters_and_Return_Values)。
 
-> 注意：元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。详情参见`类和结构体(待添加链接)`。
+> 注意：
+>
+元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构。如果你的数据结构并不是临时使用，请使用类或者结构体而不是元组。请参考[类和结构体](09_Classes_and_Structures.html)。
 
+
 ## 可选
 
-使用可选来处理值可能缺失的情况。可选表示：
+使用_可选（optionals）_来处理值可能缺失的情况。可选表示：
 
-* 有值，等于 x
+* _有_值，等于 x
 
 或者
 
-* 没有值
+* _没有_值
 
-> 注意：C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回`nil`，`nil`表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如`NSNotFound`）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。
+> 注意：
+>
+C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回`nil`，`nil`表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如`NSNotFound`）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示_任意类型_的值缺失，并不需要一个特殊值。
 
 来看一个例子。Swift 的`String`类型有一个叫做`toInt`的方法，作用是将一个`String`值转换成一个`Int`值。然而，并不是所有的字符串都可以转换成一个整数。字符串`"123"`可以被转换成数字`123`，但是字符串`"hello, world"`不行。
 
@@ -411,13 +460,13 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     let convertedNumber = possibleNumber.toInt()
     // convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
 
-因为`toInt`方法可能会失败，所以它返回一个可选的`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
+因为`toInt`方法可能会失败，所以它返回一个_可选的（optional）_`Int`，而不是一个`Int`。一个可选的`Int`被写作`Int?`而不是`Int`。问号暗示包含的值是可选，也就是说可能包含`Int`值也可能不包含值。（不能包含其他任何值比如`Bool`值或者`String`值。只能是`Int`或者什么都没有。）
 
 ### if 语句以及强制解析
 
 你可以使用`if`语句来判断一个可选是否包含值。如果可选有值，结果是`true`；如果没有值，结果是`false`。
 
-当你确定可选包含值之后，你可以在可选的名字后面加一个`!`来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的强制解析：
+当你确定可选包_确实_含值之后，你可以在可选的名字后面加一个感叹号(`!`)来获取值。这个惊叹号表示“我知道这个可选有值，请使用它。”这被称为可选值的_强制解析（forced unwrapping）_：
 
     if convertedNumber {
         println("\(possibleNumber) has an integer value of \(convertedNumber!)")
@@ -426,15 +475,17 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     }
     // 输出 "123 has an integer value of 123"
 
-更多关于`if`语句的内容参见`控制流(待添加链接)`。
+更多关于`if`语句的内容，请参考[控制流](05_Control_Flow.html)。
 
-> 注意：使用`!`来获取一个不存在的可选值会导致运行时错误。。使用`!`来强制解析值之前，一定要确定可选包含一个非`nil`的值。
+> 注意：
+>
+使用`!`来获取一个不存在的可选值会导致运行时错误。使用`!`来强制解析值之前，一定要确定可选包含一个非`nil`的值。
 
 ### 可选绑定
 
-使用可选绑定来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句详情参见`控制流`。
+使用_可选绑定（optional binding）_来判断可选是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在`if`和`while`语句中来对可选的值进行判断并把值赋给一个常量或者变量。`if`和`while`语句，请参考[控制流](05_Control_Flow.html)。
 
-像下面这样写一个可选绑定：
+像下面这样在`if`语句中写一个可选绑定：
 
     if let constantName = someOptional {
         statements
@@ -453,9 +504,9 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
 
 “如果`possibleNumber.toInt`返回的可选`Int`包含一个值，创建一个叫做`actualNumber`的新常量并将可选包含的值赋给它。”
 
-如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选包含的值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
+如果转换成功，`actualNumber`常量可以在`if`语句的第一个分支中使用。它已经被可选_包含的_值初始化过，所以不需要再使用`!`后缀来获取它的值。在这个例子中，`actualNumber`只被用来输出转换结果。
 
-你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选包含的值就会被赋给一个变量。
+你可以在可选绑定中使用常量和变量。如果你想在`if`语句的第一个分支中操作`actualNumber`的值，你可以改成`if var actualNumber`，这样可选包含的值就会被赋给一个变量而非常量。
 
 ### nil
 
@@ -466,24 +517,28 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     serverResponseCode = nil
     // serverResponseCode 现在不包含值
 
-> 注意：`nil`不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
+> 注意：
+>
+`nil`不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。
 
 如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为`nil`：
 
     var surveyAnswer: String?
     // surveyAnswer 被自动设置为 nil
 
-> 注意：Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`nil`是一个指向不存在对象的指针。在 Swift 中，`nil`不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选都可以被设置为`nil`，不只是对象类型。
+> 注意：
+>
+Swift 的`nil`和 Objective-C 中的`nil`并不一样。在 Objective-C 中，`nil`是一个指向不存在对象的指针。在 Swift 中，`nil`不是指针——它是一个确定的值，用来表示值缺失。_任何_类型的可选都可以被设置为`nil`，不只是对象类型。
 
 ### 隐式解析可选
 
 如上所述，可选暗示了常量或者变量可以“没有值”。可选可以通过`if`语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
 
-有时候在程序架构中，第一次被赋值之后，可以确定一个可选总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
+有时候在程序架构中，第一次被赋值之后，可以确定一个可选_总会_有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
 
-这种类型的可选被定义为隐式解析可选。把后缀`?`改成`!`来声明一个隐式解析可选，比如`String!`。
+这种类型的可选被定义为_隐式解析可选（implicitly unwrapped optionals）_。把想要用作可选的类型的后面的问号（`String?`）改成感叹号（`String!`）来声明一个隐式解析可选。
 
-当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，详情参见`无主引用和隐式解析可选属性(Unowned References and Implicitly Unwrapped Optional Properties待添加链接)`。
+当可选被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选非常有用。隐式解析可选主要被用在 Swift 中类的构造过程中，请参考[类实例之间的循环强引用](16_Automatic_Reference_Counting.html#strong_reference_cycles_between_class_instances)。
 
 一个隐式解析可选其实就是一个普通的可选，但是可以被当做非可选来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选`String`和隐式解析可选`String`之间的区别：
 
@@ -492,38 +547,45 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
     // 输出 "An optional string."
 
     let assumedString: String! = "An implicitly unwrapped optional string."
-    println(assumedString)  // 不需要惊叹号
+    println(assumedString)  // 不需要感叹号
     // 输出 "An implicitly unwrapped optional string."
 
-你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把惊叹号放到类型的结尾，而不是每次获取值的变量结尾。
+你可以把隐式解析可选当做一个可以自动解析的可选。你要做的只是声明的时候把感叹号放到类型的结尾，而不是每次取值的可选名字的结尾。
 
-> 注意：如果你在隐式解析可选没有值的时候尝试获取，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。
+> 注意：
+>
+如果你在隐式解析可选没有值的时候尝试取值，会触发运行时错误。和你在没有值的普通可选后面加一个惊叹号一样。
 
 你仍然可以把隐式解析可选当做普通可选来判断它是否包含值：
+
     if assumedString {
         println(assumedString)
     }
     // 输出 "An implicitly unwrapped optional string."
 
 你也可以在可选绑定中使用隐式解析可选来检查并解析它的值：
+
     if let definiteString = assumedString {
         println(definiteString)
     }
     // 输出 "An implicitly unwrapped optional string."
 
-> 注意：如果一个变量之后可能变成`nil`的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是`nil`的话，请使用普通可选类型。
+> 注意：
+>
+如果一个变量之后可能变成`nil`的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是`nil`的话，请使用普通可选类型。
 
+
 ## 断言
 
-可选可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能并不需要继续执行。这时，你可以在你的代码中触发一个断言来结束代码运行并通过调试来找到值缺失的原因。
+可选可以让你判断值是否存在，你可以在代码中优雅地处理值缺失的情况。然而，在某些情况下，如果值缺失或者值并不满足特定的条件，你的代码可能并不需要继续执行。这时，你可以在你的代码中触发一个_断言（assertion）_来结束代码运行并通过调试来找到值缺失的原因。
 
-### 使用断言来调试
+### 使用断言进行调试
 
 断言会在运行时判断一个逻辑条件是否为`true`。从字面意思来说，断言“断言”一个条件是否为真。你可以使用断言来保证在运行其他代码之前，某些重要的条件已经被满足。如果条件判断为`true`，代码运行会继续进行；如果条件判断为`false`，代码运行停止，你的应用被终止。
 
 如果你的代码在调试环境下触发了一个断言，比如你在 Xcode 中构建并运行一个应用，你可以清楚地看到不合法的状态发生在哪里并检查断言被触发时你的应用的状态。此外，断言允许你附加一条调试信息。
 
-你可以使用全局`assert`函数来写一个断言。给`assert`函数传入一个结果为`true`或者`false`的表达式以及一条信息，当表达式为`false`的时候这条信息会被显示：
+你可以使用全局`assert`函数来写一个断言。向`assert`函数传入一个结果为`true`或者`false`的表达式以及一条信息，当表达式为`false`的时候这条信息会被显示：
 
     let age = -3
     assert(age >= 0, "A person's age cannot be less than zero")
@@ -537,12 +599,14 @@ Swift 有一个基本的布尔类型，叫做`Bool`。布尔值是指逻辑，
 
 ### 何时使用断言
 
-当条件可能为假时使用断言，但是最终一定要保证条件为真，这样你的代码才能继续运行。断言的适用情景：
+当条件可能为假时使用断言，但是最终一定要_保证_条件为真，这样你的代码才能继续运行。断言的适用情景：
 
-* 整数的下标(subscript)索引被传入一个自定义下标实现，但是下标索引值可能太小或者太大。
+* 整数的附属脚本索引被传入一个自定义附属脚本实现，但是下标索引值可能太小或者太大。
 * 需要给函数传入一个值，但是非法的值可能导致函数不能正常执行。
 * 一个可选值现在是`nil`，但是后面的代码运行需要一个非`nil`值。
 
-查看`下标(链接待添加)`和`函数(链接待添加)`。
+请参考[附属脚本](12_Subscripts.html)和[函数](06_Functions.html)。
 
-> 注意：断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
+> 注意：
+>
+断言可能导致你的应用终止运行，所以你应当仔细设计你的代码来让非法条件不会出现。然而，在你的应用发布之前，有时候非法条件可能出现，这时使用断言可以快速发现问题。
diff --git a/source/chapter2/02_Basic_Operators.md b/source/chapter2/02_Basic_Operators.md
index 3642d17a..44d332ea 100644
--- a/source/chapter2/02_Basic_Operators.md
+++ b/source/chapter2/02_Basic_Operators.md
@@ -1,40 +1,44 @@
+> 翻译：xielingwang
+
+> 校对：Evilcome
+
 # 基本运算符
 -----------------
 
 本页包含内容：
 
-- [术语](#terminology) 
-- [赋值运算符](#assignment_operator) 
-- [数值运算符](#arithmetic_operators) 
-- [组合赋值运算符(Compound Assignment Operators)](#compound_assignment_operators) 
-- [比较运算符](#comparison_operators) 
-- [三目条件运算符(Ternary Conditional Operator)](#ternary_conditional_operator) 
-- [区间运算符](#range_operators) 
-- [逻辑运算符](#logical_operators) 
+- [术语](#terminology)
+- [赋值运算符](#assignment_operator)
+- [数值运算符](#arithmetic_operators)
+- [组合赋值运算符（Compound Assignment Operators）](#compound_assignment_operators)
+- [比较运算符](#comparison_operators)
+- [三元条件运算符（Ternary Conditional Operator）](#ternary_conditional_operator)
+- [区间运算符](#range_operators)
+- [逻辑运算符](#logical_operators)
 
-运算符是检查，改变，合并值的特殊符号或短语。例如，加号`+`把计算两个数的和(如 `let i = 1 + 2`)。复杂些的运行算包括逻辑与`&&`(如 `if enteredDoorCode && passedRetinaScan`)，还有自增运算符`++i`这样让自身加一的便捷运算。
+运算符是检查，改变，合并值的特殊符号或短语。例如，加号`+`将两个数相加（如`let i = 1 + 2`）。复杂些的运行算例如逻辑与运算符`&&`（如`if enteredDoorCode && passedRetinaScan`），又或让 i 值加1的便捷运算符自增运算符`++i`等。
 
-Swift支持大部分标准C语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符`=`不返回值，以防止错把等号`==`写成赋值号`=`而导致Bug。数值运算符(`+`，`-`，`*`，`/`，`%`等)会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你选择使用Swift的溢出运算符来玩溢出。具体使用请移步[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
+Swift 支持大部分标准 C 语言的运算符，且改进许多特性来减少常规编码错误。如，赋值符（`=`）不返回值，以防止把想要判断相等运算符（`==`）的地方写成赋值符导致的错误。数值运算符（`+`，`-`，`*`，`/`，`%`等）会检测并不允许值溢出，以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
 
-区别于C语言，在Swift中你可以对浮点数进行取余运算(`%`)，还提供了C语言没有的表达两数之间的值的区间运算符，(`a..b`和`a...b`)，这方便我们表达一个区间内的数值。
+区别于 C 语言，在 Swift 中你可以对浮点数进行取余运算（`%`），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符，（`a..b`和`a...b`），这方便我们表达一个区间内的数值。
 
-本章节只描述了Swift中的基本运算符，[高级运算符](23_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
+本章节只描述了 Swift 中的基本运算符，[高级运算符](23_Advanced_Operators.html)包含了高级运算符，及如何自定义运算符，及如何进行自定义类型的运算符重载。
 
 
 ## 术语
 
-运算符有一目，双目和三目运算符。
+运算符有一元，二元和三元运算符。
 
-- 一目运算符对单一操作对象操作，如`-a`。一目运算符分前置符和后置运算符，前置运算符需紧排操作对象之前，如`!b`，后置运算符需紧跟操作对象之后，如`i++`，
-- 双目运算符操作两个操作对象，如 `2 + 3`。是中置的，因为它们出现在两个操作对象之间。
-- 三目运算符操作三个操作对象，和C语言一样，Swift只有一个三目运算符，就是三目条件运算符 `a？b：c`。
+- 一元运算符对单一操作对象操作（如`-a`）。一元运算符分前置符和后置运算符，前置运算符需紧排操作对象之前（如`!b`），后置运算符需紧跟操作对象之后（如`i++`）。
+- 二元运算符操作两个操作对象（如`2 + 3`），是中置的，因为它们出现在两个操作对象之间。
+- 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三元条件运算符（`a ? b : c`）。
 
-受运算符影响的值叫操作数，在表达式`1 + 2`中，加号`+`是双目运算符，它的两个操作数是值`1`和`2`。
+受运算符影响的值叫操作数，在表达式`1 + 2`中，加号`+`是二元运算符，它的两个操作数是值`1`和`2`。
 
 
 ## 赋值运算符
 
-赋值运算 `a = b`，表示用`b`的值来初始化或更新`a`的值。
+赋值运算（`a = b`），表示用`b`的值来初始化或更新`a`的值：
 
 ```swift
 let b = 10
@@ -43,12 +47,14 @@ a = b
 // a 现在等于 10
 ```
 
-如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量
+如果赋值的右边是一个多元组，它的元素可以马上被分解多个变量或变量：
+
 ```
 let (x, y) = (1, 2)
 // 现在 x 等于 1, y 等于 2
 ```
-与C语言和Objective-C不同，Swift的赋值操作并不返回任何值。所以以下代码是错误的：
+
+与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以以下代码是错误的：
 
 ```swift
 if x = y {
@@ -56,17 +62,17 @@ if x = y {
 }
 ```
 
-这个特性使得你不无法把`==`错写成`=`了，由于`if x = y`是错误代码，Swift从底层帮你避免了这些代码错误。
+这个特性使得你无法把（`==`）错写成（`=`）了，由于`if x = y`是错误代码，Swift 从底层帮你避免了这些代码错误。
 
 
 ## 数值运算
 
-Swift让所有数值类型都支持了基本的四则运算：
+Swift 让所有数值类型都支持了基本的四则运算：
 
-- 加法`+`
-- 减法`-`
-- 乘法`*`
-- 除法`/`
+- 加法（`+`）
+- 减法（`-`）
+- 乘法（`*`）
+- 除法（`/`）
 
 ```swift
 1 + 2       // 等于 3
@@ -75,15 +81,15 @@ Swift让所有数值类型都支持了基本的四则运算：
 10.0 / 2.5  // 等于 4.0
 ```
 
-与C语言和Objective-C不同的是，Swift默认不允许在数值运算中出现溢出情况。但你可以使用Swift的溢出运算符来达到你有目的的溢出，(如 `a &+ b`)。详情请移步：[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
+与 C 语言和 Objective-C 不同的是，Swift 默认不允许在数值运算中出现溢出情况。但你可以使用 Swift 的溢出运算符来达到你有目的的溢出（如`a &+ b`）。详情参见[溢出运算符](23_Advanced_Operators.html#overflow_operators)。
 
-加法操作`+`也用于字符串的拼接：
+加法运算符也用于`String`的拼接：
 
 ```swift
 "hello, " + "world"  // 等于 "hello, world"
 ```
 
-两个字符类型或一个字符类型和一个字符串类型，相加会生成一个新的字符串类型：
+两个`Character`值或一个`String`和一个`Character`值，相加会生成一个新的`String`值：
 
 ```swift
 let dog: Character = "d"
@@ -92,29 +98,30 @@ let dogCow = dog + cow
 // 译者注: 原来的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符
 // dogCow 现在是 "dc"
 ```
-详细请点击[字符，字符串的拼接](03_Strings_and_Characters.html#concatenating_strings_and_characters)。
+
+详情参见[字符，字符串的拼接](03_Strings_and_Characters.html#concatenating_strings_and_characters)。
 
 ### 求余运算
 
-求余运算 `a % b` 是计算`b`的多少倍刚刚好可以容入`a`，多出来的那部分叫余数。
+求余运算（`a % b`）是计算`b`的多少倍刚刚好可以容入`a`，返回多出来的那部分（余数）。
 
 >注意：
-求余运算(%)在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。
-
-我们来谈谈取余是怎么回事，计算`9 % 4`，你先计算出4的多少倍会刚好可以容入`9`中。
-
-2倍，非常好，那余数是1(用橙色标出)
+>
+求余运算（`%`）在其他语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果，"求余"比"取模"更合适些。
 
+我们来谈谈取余是怎么回事，计算`9 % 4`，你先计算出`4`的多少倍会刚好可以容入`9`中：
 
 ![Art/remainderInteger_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderInteger_2x.png "Art/remainderInteger_2x.png")
 
-在Swift中这么来表达
+2倍，非常好，那余数是1（用橙色标出）
+
+在 Swift 中这么来表达：
 
 ```swift
 9 % 4    // 等于 1
 ```
 
-为了得到 `a % b` 的结果，`%`计算了以下等式，并输出`余数`作为结果：
+为了得到`a % b`的结果，`%`计算了以下等式，并输出`余数`作为结果：
 
 *a = (b × 倍数) + 余数*
 
@@ -127,7 +134,8 @@ let dogCow = dog + cow
 ```
 
 同样的方法，我来们计算 `-9 % 4`：
-```
+
+```swift
 -9 % 4   // 等于 -1
 ```
 
@@ -139,41 +147,40 @@ let dogCow = dog + cow
 
 余数是`-1`。
 
-在对负数`-b`求余时，`-b`的符号会被忽略。这意味着 `a % b` 和 `a % -b`的结果是相同的。
+在对负数`b`求余时，`b`的符号会被忽略。这意味着 `a % b` 和 `a % -b`的结果是相同的。
 
 ### 浮点数求余计算
 
-不同于C和Objective-C，Swift中是可以对浮点数进行求余的。
+不同于 C 语言和 Objective-C，Swift 中是可以对浮点数进行求余的。
 
 ```swift
 8 % 2.5 // 等于 0.5
 ```
 
-这个例子中，8除于2.5等于3余0.5，所以结果是0.5。
+这个例子中，`8`除于`2.5`等于`3`余`0.5`，所以结果是一个`Double`值`0.5`。
 
 ![Art/remainderFloat_2x.png](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/remainderFloat_2x.png "Art/remainderFloat_2x.png")
 
 ### 自增和自增运算
 
-和C一样，Swift也提供了方便对变量本身加1或减1的自增`++`和自减`--`的运算符。其操作对象可以是整形和浮点型。
+和 C 语言一样，Swift 也提供了方便对变量本身加1或减1的自增（`++`）和自减（`--`）的运算符。其操作对象可以是整形和浮点型。
 ‌
-```
+```swift
 var i = 0
 ++i      // 现在 i = 1
 ```
 
-每调用一次`++i`，`i`的值就会加1。
-实际上，`++i`是 `i = i + 1` 的简写，而`--i`是 `i = i - 1`的简写。
+每调用一次`++i`，`i`的值就会加1。实际上，`++i`是`i = i + 1`的简写，而`--i`是`i = i - 1`的简写。
 
 `++`和`--`既是前置又是后置运算。`++i`，`i++`，`--i`和`i--`都是有效的写法。
 
 我们需要注意的是这些运算符修改了`i`后有一个返回值。如果你只想修改`i`的值，那你就可以忽略这个返回值。但如果你想使用返回值，你就需要留意前置和后置操作的返回值是不同的。
 
-当`++`前置的时候，先自増再返回。
+- 当`++`前置的时候，先自増再返回。
 
-当`++`后置的时候，先返回再自增。
+- 当`++`后置的时候，先返回再自增。
 
-不懂？我们看例子：
+例如：
 
 ```swift
 var a = 0
@@ -181,16 +188,16 @@ let b = ++a // a 和 b 现在都是 1
 let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
 ```
 
-上述例子，`let b = ++a`，先把`a`加1了再返回`a`的值。所以`a`和`b`都是新值`1`。
+上述例子，`let b = ++a`先把`a`加1了再返回`a`的值。所以`a`和`b`都是新值`1`。
 
-而 `let c = a++`，是先返回了`a`的值，然后`a`才加1。所以`c`得到了`a`的旧值1，而`a`加1后变成2。
+而`let c = a++`，是先返回了`a`的值，然后`a`才加1。所以`c`得到了`a`的旧值1，而`a`加1后变成2。
 
 除非你需要使用`i++`的特性，不然推荐你使用`++i`和`--i`，因为先修改后返回这样的行为更符合我们的逻辑。
 
 
-### 单目负号
+### 一元负号
 
-数值的正负号可以使用前缀`-`(即单目负号)来切换：
+数值的正负号可以使用前缀`-`（即一元负号）来切换：
 
 ```swift
 let three = 3
@@ -198,50 +205,52 @@ let minusThree = -three       // minusThree 等于 -3
 let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"
 ```
 
-单目负号写在操作数之前，中间没有空格。
+一元负号（`-`）写在操作数之前，中间没有空格。
 
-### 单目正号
+### 一元正号
 
-单目正号`+`不做任何改变地返回操作数的值。
+一元正号（`+`）不做任何改变地返回操作数的值。
 
 ```swift
 let minusSix = -6
 let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6
 ```
-虽然单目`+`做无用功，但当你在使用单目负号来表达负数时，你可以使用单目正号来表达正数，如此你的代码会具有对称美。
+虽然一元`+`做无用功，但当你在使用一元负号来表达负数时，你可以使用一元正号来表达正数，如此你的代码会具有对称美。
 
 
 
-## 复合赋值
+## 复合赋值（Compound Assignment Operators）
 
-如同强大的C语言，Swift也提供把其他运算符和赋值运算`=`组合的复合赋值运算符，加赋运算`+=`是其中一个例子：
+如同强大的 C 语言，Swift 也提供把其他运算符和赋值运算（`=`）组合的复合赋值运算符，加赋运算（`+=`）是其中一个例子：
 
 ```swift
 var a = 1
 a += 2 // a 现在是 3
 ```
 
-表达式 `a += 2` 是 `a = a + 2` 的简写，一个加赋运算就把加法和赋值两件事完成了。
+表达式`a += 2`是`a = a + 2`的简写，一个加赋运算就把加法和赋值两件事完成了。
 
 >注意：
-复合赋值运算没有返回值，`let b = a += 2` 这类代码是错误。这不同于上面提到的自增和自减运算符。
+>
+复合赋值运算没有返回值，`let b = a += 2`这类代码是错误。这不同于上面提到的自增和自减运算符。
 
 在[表达式](../chapter3/04_Expressions.html)章节里有复合运算符的完整列表。
 ‌
 
 ## 比较运算
 
-所有标准C中的比较运算都可以在Swift中使用。
+所有标准 C 语言中的比较运算都可以在 Swift 中使用。
 
-- 等于 `a == b`
-- 不等于 `a！= b`
-- 大于 `a > b`
-- 小于 `a < b`
-- 大于等于 `a >= b`
-- 小于等于 `a <= b`
+- 等于（`a == b`）
+- 不等于（`a！= b`）
+- 大于（`a > b`）
+- 小于（`a < b`）
+- 大于等于（`a >= b`）
+- 小于等于（`a <= b`）
 
 > 注意：
-Swift也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。
+>
+Swift 也提供恒等`===`和不恒等`!==`这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在[类与结构](09_Classes_and_Structures.html)。
 
 每个比较运算都返回了一个标识表达式是否成立的布尔值：
 
@@ -261,7 +270,7 @@ let name = "world"
 if name == "world" {
     println("hello, world")
 } else {
-    println("对不起, \(name), 我不认识你!")
+    println("I'm sorry \(name), but I don't recognize you")
 }
 // 输出 "hello, world", 因为 `name` 就是等于 "world"
 ```
@@ -269,18 +278,18 @@ if name == "world" {
 关于`if`语句，请看[控制流](05_Control_Flow.html)。
 
 
-## 三目条件运算
+## 三元条件运算(Ternary Conditional Operator)
 
-三目条件运算的特殊在于它是有三个操作数的运算符，它的原型是 `问题？答案1：答案2`。它简洁地表达根据 `问题` 成立与否作出二选一的操作。如果 `问题` 成立，返回 `答案1` 的结果; 如果不成立，返回 `答案2` 的结果。
+三元条件运算的特殊在于它是有三个操作数的运算符，它的原型是`问题？答案1：答案2`。它简洁地表达根据`问题`成立与否作出二选一的操作。如果`问题`成立，返回`答案1`的结果; 如果不成立，返回`答案2`的结果。
 
-使用三目条件运算简化了以下代码：
+使用三元条件运算简化了以下代码：
 
 ```swift
 if question: {
-  answer1
+	answer1
 }
 else {
-  answer2
+	answer2
 }
 ```
 
@@ -307,23 +316,23 @@ if hasHeader {
 // rowHeight 现在是 90
 ```
 
-第一段代码例子使用了三目条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将`rowHeight`定义成变量，因为它的值无需在`if`语句中改变。
+第一段代码例子使用了三元条件运算，所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多，无需将`rowHeight`定义成变量，因为它的值无需在`if`语句中改变。
 
-三目条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三目条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三目条件运算符。
+三元条件运算提供有效率且便捷的方式来表达二选一的选择。需要注意的事，过度使用三元条件运算就会由简洁的代码变成难懂的代码。我们应避免在一个组合语句使用多个三元条件运算符。
 
 
 ## 区间运算符
 
-Swift提供了两个方便表达一个区间的值的运算符。
+Swift 提供了两个方便表达一个区间的值的运算符。
 
 ### 闭区间运算符
-闭区间运算符`a...b`定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间。
+闭区间运算符（`a...b`）定义一个包含从`a`到`b`(包括`a`和`b`)的所有值的区间。
 ‌
 闭区间运算符在迭代一个区间的所有值时是非常有用的，如在`for-in`循环中：
 
 ```swift
 for index in 1...5 {
-  println("\(index) * 5 = \(index * 5)")
+  	println("\(index) * 5 = \(index * 5)")
 }
 // 1 * 5 = 5
 // 2 * 5 = 10
@@ -336,7 +345,7 @@ for index in 1...5 {
 
 ### 半闭区间
 
-半闭区间`a..b`定义一个从`a`到`b`但不包括`b`的区间。
+半闭区间（`a..b`）定义一个从`a`到`b`但不包括`b`的区间。
 之所以称为半闭区间，是因为该区间包含第一个值而不包括最后的值。
 
 半闭区间的实用性在于当你使用一个0始的列表(如数组)时，非常方便地从0数到列表的长度。
@@ -353,30 +362,29 @@ for i in 0..count {
 // 第 4 个人叫 Jack
 ```
 
-> 注意：
-数组有4个元素，但`0..count`只数到 3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。
+数组有4个元素，但`0..count`只数到3(最后一个元素的下标)，因为它是半闭区间。关于数组，请查阅[数组](04_Collection_Types.html#arrays)。
 
 
 ## 逻辑运算
 
-逻辑运算的操作对象是逻辑布尔值。Swift支持基于C语言的三个标准逻辑运算。
+逻辑运算的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
 
-- 逻辑非`!a`
-- 逻辑与 `a && b`
-- 逻辑或 `a || b`
+- 逻辑非（`!a`）
+- 逻辑与（`a && b`）
+- 逻辑或（`a || b`）
 
 ### 逻辑非
 
-逻辑非运算`!a`对一个布尔值取反，使得`true`变`false`，`false`变`true`。
+逻辑非运算（`!a`）对一个布尔值取反，使得`true`变`false`，`false`变`true`。
 
-它是一个前置运算符，需出现在操作数之前，且不加空格。读作 `非 a`，然后我们看以下例子：
+它是一个前置运算符，需出现在操作数之前，且不加空格。读作`非 a`，然后我们看以下例子：
 
 ```swift
 let allowedEntry = false
 if !allowedEntry {
     println("ACCESS DENIED")
 }
-// prints "ACCESS DENIED"
+// 输出 "ACCESS DENIED"
 ```
 
 `if！allowedEntry`语句可以读作 "如果 非 alowed entry。"，接下一行代码只有在如果 "非 allow entry" 为`true`，即`allowEntry`为`false`时被执行。
@@ -384,11 +392,11 @@ if !allowedEntry {
 在示例代码中，小心地选择布尔常量或变量有助于代码的可读性，并且避免使用双重逻辑非运算，或混乱的逻辑语句。
 
 ### 逻辑与
-逻辑与 `a && b` 表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。
+逻辑与（`a && b`）表达了只有`a`和`b`的值都为`true`时，整个表达式的值才会是`true`。
 
-只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算"。
+只要任意一个值为`false`，整个表达式的值就为`false`。事实上，如果第一个值为`false`，那么是不去计算第二个值的，因为它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。
 
-以下例子，只有两个值都为值的时候才允许进入：
+以下例子，只有两个`Bool`值都为`true`值的时候才允许进入：
 
 ```swift
 let enteredDoorCode = true
@@ -398,15 +406,15 @@ if enteredDoorCode && passedRetinaScan {
 } else {
     println("ACCESS DENIED")
 }
-// 输出 "ACCESS DENIED
+// 输出 "ACCESS DENIED"
 ```
 
 ### 逻辑或
-逻辑或 `a || b` 是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。
+逻辑或（`a || b`）是一个由两个连续的`|`组成的中置运算符。它表示了两个逻辑表达式的其中一个为`true`，整个表达式就为`true`。
 
 同逻辑与运算类似，逻辑或也是"短路计算"的，当左端的表达式为`true`时，将不计算右边的表达式了，因为它不可能改变整个表达式的值了。
 
-以下示例代码中，第一个布尔值`hasDoorKey`为`false`，但第二个值`knowsOverridePassword`为`true`，所以整个表达是`true`，于是允许进入：
+以下示例代码中，第一个布尔值（`hasDoorKey`）为`false`，但第二个值（`knowsOverridePassword`）为`true`，所以整个表达是`true`，于是允许进入：
 
 ```swift
 let hasDoorKey = false
@@ -440,7 +448,7 @@ if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
 
 ### 使用括号来明确优先级
 
-为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确。
+为了一个复杂表达式更容易读懂，在合适的地方使用括号来明确优先级是很有效的，虽然它并非必要的。在上个关于门的权限的例子中，我们给第一个部分加个括号，使用它看起来逻辑更明确：
 
 ```swift
 if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
@@ -448,9 +456,7 @@ if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword
 } else {
     println("ACCESS DENIED")
 }
-// prints "Welcome!"
+// 输出 "Welcome!"
 ```
 
-这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。
-
-可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！
+这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰地地方加个括号吧！
diff --git a/source/chapter2/03_Strings_and_Characters.md b/source/chapter2/03_Strings_and_Characters.md
index 5c249ed8..0857c2c1 100644
--- a/source/chapter2/03_Strings_and_Characters.md
+++ b/source/chapter2/03_Strings_and_Characters.md
@@ -1,45 +1,44 @@
-# 字符串和字符 (Strings and Characters)
+> 翻译：wh1100717
+
+> 校对：Hawstein
+
+# 字符串和字符（Strings and Characters）
 -----------------
 
 本页包含内容：
 
--   字符串字面量
--   初始化空字符串
--   字符串可变性
--   字符串是值类型
--   使用字符
--   计算字符数量
--   连接字符串和字符
--   字符串插值
--   比较字符串
--   字符串大小写
--   Unicode
+- [字符串字面量](#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** 是例如 "hello, world", "海贼王" 这样的有序的 **Character** (字符) 类型的值的集合，通过 **String** 类型来表示。
+`String`是例如“hello, world“”，“海贼王” 这样的有序的`Character`（字符）类型的值的集合，通过`String`类型来表示。
 
-Swift 的 **String** 和 **Character** 类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
+Swift 的`String`和`Character`类型提供了一个快速的，兼容 Unicode 的方式来处理代码中的文本信息。
 创建和操作字符串的语法与 C 语言中字符串操作相似，轻量并且易读。
 字符串连接操作只需要简单地通过`+`号将两个字符串相连即可。
 与 Swift 中其他值一样，能否更改字符串的值，取决于其被定义为常量还是变量。
 
-尽管语法简易，但 **String** 类型是一种快速、现代化的字符串实现。
-每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示 (representations) 来访问这些字符的支持。
+尽管语法简易，但`String`类型是一种快速、现代化的字符串实现。
+每一个字符串都是由独立编码的 Unicode 字符组成，并提供了以不同 Unicode 表示（representations）来访问这些字符的支持。
 
-Swift可以在常量、变量、字面量和表达式中进行字符串插值操作，可以轻松创建用于展示、存储和打印的自定义字符串。
+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)(**章节信息url需要替换**)。
+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)。
 
 
-### 字符串字面量 (String Literals)
-
----
+## 字符串字面量（String Literals）
 
 您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。
 字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。
@@ -51,14 +50,15 @@ let someString = "Some string literal value"
 ```
 
 > 注意：
-> `someString`变量通过字符串字面量进行初始化，Swift 因此推断该变量为 **String** 类型。
+>
+`someString`变量通过字符串字面量进行初始化，Swift 因此推断该变量为`String`类型。
 
 字符串字面量可以包含以下特殊字符：
 
-*   转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
-*   单字节 Unicode 标量，写成`\xnn`，其中`nn`为两位十六进制数。
-*   双字节 Unicode 标量，写成`\unnnn`，其中`nnnn`为四位十六进制数。
-*   四字节 Unicode 标量，写成`\Unnnnnnnn`，其中`nnnnnnnn`为八位十六进制数。
+* 转义字符`\0`(空字符)、`\\`(反斜线)、`\t`(水平制表符)、`\n`(换行符)、`\r`(回车符)、`\"`(双引号)、`\'`(单引号)。
+* 单字节 Unicode 标量，写成`\xnn`，其中`nn`为两位十六进制数。
+* 双字节 Unicode 标量，写成`\unnnn`，其中`nnnn`为四位十六进制数。
+* 四字节 Unicode 标量，写成`\Unnnnnnnn`，其中`nnnnnnnn`为八位十六进制数。
 
 下面的代码为各种特殊字符的使用示例。
 `wiseWords`常量包含了两个转移特殊字符 (双括号)；
@@ -73,12 +73,10 @@ let sparklingHeart = "\U0001F496"	// 💖, Unicode 标量 U+1F496
 ```
 
 
-### 初始化空字符串 (Initializing an Empty String)
-
----
+## 初始化空字符串 (Initializing an Empty String)
 
 为了构造一个很长的字符串，可以创建一个空字符串作为初始值。
-可以将空的字符串字面量赋值给变量，也可以初始化一个新的 **String** 实例：
+可以将空的字符串字面量赋值给变量，也可以初始化一个新的`String`实例：
 
 ```
 var emptyString = ""               // 空字符串字面量
@@ -86,19 +84,17 @@ var anotherEmptyString = String()  // 初始化 String 实例
 // 两个字符串均为空并等价。
 ```
 
-您可以通过检查其 **Boolean** 类型的`isEmpty`属性来判断该字符串是否为空：
+您可以通过检查其`Boolean`类型的`isEmpty`属性来判断该字符串是否为空：
 
 ```
 if emptyString.isEmpty {
     println("什么都没有")
 }
-// 输出 "什么都没有"
+// 打印输出："什么都没有"
 ```
 
 
-### 字符串可变性 (String Mutability)
-
----
+## 字符串可变性 (String Mutability)
 
 您可以通过将一个特定字符串分配给一个变量来对其进行修改，或者分配给一个常量来保证其不会被修改：
 
@@ -112,20 +108,20 @@ constantString += " and another Highlander"
 ```
 
 > 注意：
-> 在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。
+>
+在 Objective-C 和 Cocoa 中，您通过选择两个不同的类(`NSString`和`NSMutableString`)来指定该字符串是否可以被修改，Swift 中的字符串是否可以修改仅通过定义的是变量还是常量来决定，实现了多种类型可变性操作的统一。
 
 
-### 字符串是值类型 (Strings Are Value Types)
+## 字符串是值类型（Strings Are Value Types）
 
----
-
-Swift 的 **String** 类型是值类型。
+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)(**章节信息URL需要替换**) 中进行了说明。
+值类型在 [结构体和枚举是值类型](09_Classes_and_Structures.html#structures_and_enumerations_are_value_types) 中进行了说明。
 
 > 注意：
-> 与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
+>
+与 Cocoa 中的`NSString`不同，当您在 Cocoa 中创建了一个`NSString`实例，并将其传递给一个函数/方法，或者赋值给一个变量，您传递或赋值的是该`NSString`实例的一个引用，除非您特别要求进行值拷贝，否则字符串不会生成新的副本来进行赋值操作。
 
 Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。
 很明显无论该值来自于哪里，都是您独自拥有的。
@@ -134,11 +130,9 @@ Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字
 在实际编译时，Swift 编译器会优化字符串的使用，使实际的复制只发生在绝对必要的情况下，这意味着您将字符串作为值类型的同时可以获得极高的性能。
 
 
-### 使用字符 (Working with Characters)
+## 使用字符（Working with Characters）
 
----
-
-Swift 的 **String** 类型表示特定序列的 **Character** (字符) 类型值的集合。
+Swift 的`String`类型表示特定序列的`Character`（字符） 类型值的集合。
 每一个字符值代表一个 Unicode 字符。
 您可利用`for-in`循环来遍历字符串中的每一个字符：
 
@@ -153,43 +147,35 @@ 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)(**章节信息URL需要替换**)中进行了详细描述。
+for-in 循环在 [For Loops](05_Control_Flow.html#for_loops) 中进行了详细描述。
 
-另外，通过标明一个 **Character** 类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：
+另外，通过标明一个`Character`类型注解并通过字符字面量进行赋值，可以建立一个独立的字符常量或变量：
 
 ```
 let yenSign: Character = "¥"
 ```
 
 
-### 计算字符数量 (Counting Characters)
-
----
+## 计算字符数量 (Counting Characters)
 
 通过调用全局`countElements`函数，并将字符串作为参数进行传递，可以获取该字符串的字符数量。
 
 ```
 let unusualMenagerie = "Koala 🐨, Snail 🐌, Penguin 🐧, Dromedary 🐪"
 println("unusualMenagerie has \(countElements(unusualMenagerie)) characters")
-// prints "unusualMenagerie has 40 characters"
+// 打印输出："unusualMenagerie has 40 characters"
 ```
 
 > 注意：
-> 不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。
-> 所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。
-> 因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。
-> 如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。
 >
-> 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。
-> `NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。
-> 为了解决这个问题，`NSString`的`length`属性在被 Swift 的 **String** 访问时会成为`utf16count`。
+不同的 Unicode 字符以及相同 Unicode 字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间。因此字符串的长度不得不通过迭代字符串中每一个字符的长度来进行计算。如果您正在处理一个长字符串，需要注意`countElements`函数必须遍历字符串中的字符以精准计算字符串的长度。
+>
+> 另外需要注意的是通过`countElements`返回的字符数量并不总是与包含相同字符的`NSString`的`length`属性相同。`NSString`的`length`属性是基于利用 UTF-16 表示的十六位代码单元数字，而不是基于 Unicode 字符。为了解决这个问题，`NSString`的`length`属性在被 Swift 的`String`访问时会成为`utf16count`。
 
 
-### 连接字符串和字符 (Concatenating Strings and Characters)
+## 连接字符串和字符 (Concatenating Strings and Characters)
 
----
-
-字符串和字符的值可以通过加法运算符 (`+`) 相加在一起并创建一个新的字符串值：
+字符串和字符的值可以通过加法运算符（`+`）相加在一起并创建一个新的字符串值：
 
 ```
 let string1 = "hello"
@@ -215,13 +201,12 @@ welcome += character1
 // welcome 现在等于 "good morning!"
 ```
 
->注意：
->您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
+> 注意：
+>
+您不能将一个字符串或者字符添加到一个已经存在的字符变量上，因为字符变量只能包含一个字符。
 
 
-### 字符串插值 (String Interpolation)
-
----
+## 字符串插值 (String Interpolation)
 
 字符串插值是一种构建新字符串的方式，可以在其中包含常量、变量、字面量和表达式。
 您插入的字符串字面量的每一项都被包裹在以反斜线为前缀的圆括号中：
@@ -229,7 +214,7 @@ welcome += character1
 ```
 let multiplier = 3
 let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
-// message is "3 乘以 2.5 是 7.5"
+// message 是 "3 乘以 2.5 是 7.5"
 ```
 
 在上面的例子中，`multiplier`作为`\(multiplier)`被插入到一个字符串字面量中。
@@ -239,18 +224,17 @@ let message = "\(multiplier) 乘以 2.5 是 \(Double(multiplier) * 2.5)"
 该表达式计算`Double(multiplier) * 2.5`的值并将结果 (7.5) 插入到字符串中。
 在这个例子中，表达式写为`\(Double(multiplier) * 2.5)`并包含在字符串字面量中。
 
->注意：
->您插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
+> 注意：
+>
+您插值字符串中写在括号中的表达式不能包含非转义双引号 (`"`) 和反斜杠 (`\`)，并且不能包含回车或换行符。
 
 
-### 比较字符串 (Comparing Strings)
-
----
+## 比较字符串 (Comparing Strings)
 
 Swift 提供了三种方式来比较字符串的值：字符串相等、前缀相等和后缀相等。
 
 
-##### 字符串相等 (String Equality)
+### 字符串相等 (String Equality)
 
 如果两个字符串以同一顺序包含完全相同的字符，则认为两者字符串相等：
 
@@ -260,14 +244,14 @@ let sameQuotation = "我们是一样一样滴."
 if quotation == sameQuotation {
     println("这两个字符串被认为是相同的")
 }
-// prints "这两个字符串被认为是相同的"
+// 打印输出："这两个字符串被认为是相同的"
 ```
 
 
-##### 前缀/后缀相等 (Prefix and Suffix Equality)
+### 前缀/后缀相等 (Prefix and Suffix Equality)
 
 通过调用字符串的`hasPrefix`/`hasSuffix`方法来检查字符串是否拥有特定前缀/后缀。
-两个方法均需要以字符串作为参数传入并传出 **Boolean** 值。
+两个方法均需要以字符串作为参数传入并传出`Boolean`值。
 两个方法均执行基本字符串和前缀/后缀字符串之间逐个字符的比较操作。
 
 下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置：
@@ -298,11 +282,27 @@ for scene in romeoAndJuliet {
     }
 }
 println("There are \(act1SceneCount) scenes in Act 1")
-// prints "There are 5 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
+    }
+}
+println("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
+// 打印输出："6 mansion scenes; 2 cell scenes”
 ```
 
 
-##### 大写和小写字符串 (Uppercase and Lowercase Strings)
+### 大写和小写字符串（Uppercase and Lowercase Strings）
 
 您可以通过字符串的`uppercaseString`和`lowercaseString`属性来访问大写/小写版本的字符串。
 
@@ -315,9 +315,7 @@ let whispered = normal.lowercaseString
 ```
 
 
-### Unicode
-
----
+## Unicode
 
 Unicode 是一个国际标准，用于文本的编码和表示。
 它使您可以用标准格式表示来自任意语言几乎所有的字符，并能够对文本文件或网页这样的外部资源中的字符进行读写操作。
@@ -325,26 +323,26 @@ Unicode 是一个国际标准，用于文本的编码和表示。
 Swift 的字符串和字符类型是完全兼容 Unicode 标准的，它支持如下所述的一系列不同的 Unicode 编码。
 
 
-###### Unicode 术语 (Unicode Terminology)
+### Unicode 术语（Unicode Terminology）
 
 Unicode 中每一个字符都可以被解释为一个或多个 unicode 标量。
-字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小幺鸡表情 ("🐥")
+字符的 unicode 标量是一个唯一的21位数字(和名称)，例如`U+0061`表示小写的拉丁字母A ("a")，`U+1F425`表示小鸡表情 ("🐥")
 
-当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`(以8位代码单元进行编码) 和`UTF-16`(以16位代码单元进行编码)。
+当 Unicode 字符串被写进文本文件或其他存储结构当中，这些 unicode 标量将会按照 Unicode 定义的集中格式之一进行编码。其包括`UTF-8`（以8位代码单元进行编码） 和`UTF-16`（以16位代码单元进行编码）。
 
 
-##### 字符串的 Unicode 表示 (Unicode Representations of Strings)
+### 字符串的 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)(**章节信息URL需要替换**) 中进行了描述。
+该过程在 [使用字符](#working_with_characters) 中进行了描述。
 
 另外，能够以其他三种 Unicode 兼容的方式访问字符串的值：
 
-*   UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
-*   UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
-*   21位的 Unicode 标量值集合 (利用字符串的`unicodeScalars`属性进行访问)
+* UTF-8 代码单元集合 (利用字符串的`utf8`属性进行访问)
+* UTF-16 代码单元集合 (利用字符串的`utf16`属性进行访问)
+* 21位的 Unicode 标量值集合 (利用字符串的`unicodeScalars`属性进行访问)
 
 下面由`D``o``g``!`和`🐶`(`DOG FACE`，Unicode 标量为`U+1F436`)组成的字符串中的每一个字符代表着一种不同的表示：
 
@@ -353,10 +351,10 @@ let dogString = "Dog!🐶"
 ```
 
 
-##### UTF-8
+### UTF-8
 
 您可以通过遍历字符串的`utf8`属性来访问它的`UTF-8`表示。
-其为 **UTF8View** 类型的属性，**UTF8View** 是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
+其为`UTF8View`类型的属性，`UTF8View`是无符号8位 (`UInt8`) 值的集合，每一个`UInt8`值都是一个字符的 UTF-8 表示：
 
 ```
 for codeUnit in dogString.utf8 {
@@ -367,13 +365,13 @@ print("\n")
 ```
 
 上面的例子中，前四个10进制代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，他们的 UTF-8 表示与 ASCII 表示相同。
-后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4位 UTF-8 表示。
+后四个代码单元值 (240, 159, 144, 182) 是`DOG FACE`的4字节 UTF-8 表示。
 
 
-##### UTF-16
+### UTF-16
 
 您可以通过遍历字符串的`utf16`属性来访问它的`UTF-16`表示。
-其为 **UTF16View** 类型的属性，**UTF16View** 是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
+其为`UTF16View`类型的属性，`UTF16View`是无符号16位 (`UInt16`) 值的集合，每一个`UInt16`都是一个字符的 UTF-16 表示：
 
 ```
 for codeUnit in dogString.utf16 {
@@ -385,14 +383,14 @@ print("\n")
 
 同样，前四个代码单元值 (68, 111, 103, 33) 代表了字符`D` `o` `g`和`!`，他们的 UTF-16 代码单元和 UTF-8 完全相同。
 
-第五和第六个代码单元值 (55357 and 56374) 是`DOG FACE`字符的UTF-16 表示。
+第五和第六个代码单元值 (55357 和 56374) 是`DOG FACE`字符的UTF-16 表示。
 第一个值为`U+D83D`(十进制值为 55357)，第二个值为`U+DC36`(十进制值为 56374)。
 
 
-##### Unicode 标量 (Unicode Scalars)
+### Unicode 标量 (Unicode Scalars)
 
 您可以通过遍历字符串的`unicodeScalars`属性来访问它的 Unicode 标量表示。
-其为 **UnicodeScalarView** 类型的属性， **UnicodeScalarView** 是`UnicodeScalar`的集合。
+其为`UnicodeScalarView`类型的属性， `UnicodeScalarView`是`UnicodeScalar`的集合。
 `UnicodeScalar`是21位的 Unicode 代码点。
 
 每一个`UnicodeScalar`拥有一个值属性，可以返回对应的21位数值，用`UInt32`来表示。
diff --git a/source/chapter2/04_Collection_Types.md b/source/chapter2/04_Collection_Types.md
index c545d875..a8698864 100644
--- a/source/chapter2/04_Collection_Types.md
+++ b/source/chapter2/04_Collection_Types.md
@@ -1,24 +1,35 @@
 # 集合类型 (Collection Types)
 -----------------
 
-Swift语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
+本页包含内容：
 
-Swift语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
+- [数组（Arrays）](#arrays)
+- [字典（Dictionaries）](#dictionaries)
+- [集合的可变性（Mutability of Collections）](#mutability_of_collections)
+
+Swift 语言提供经典的数组和字典两种集合类型来存储集合数据。数组用来按顺序存储相同类型的数据。字典虽然无序存储相同类型数据值但是需要由独有的标识符引用和寻址（就是键值对）。
+
+Swift 语言里的数组和字典中存储的数据值类型必须明确。 这意味着我们不能把不正确的数据类型插入其中。 同时这也说明我们完全可以对获取出的值类型非常自信。 Swift 对显式类型集合的使用确保了我们的代码对工作所需要的类型非常清楚，也让我们在开发中可以早早地找到任何的类型不匹配错误。
 
 > 注意：
-Swift的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见see Mutability of Collections and Assignment and Copy Behavior for Collection Types。（集合的可变性与集合在赋值和复制中的行为章节）
-
+>
+Swift 的数组结构在被声明成常量和变量或者被传入函数与方法中时会相对于其他类型展现出不同的特性。 获取更多信息请参见[集合的可变性](#mutability_of_collections)与[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)章节。
 
+
 ## 数组
 
 数组使用有序列表存储相同类型的多重数据。相同的值可以多次出现在一个数组的不同位置中。
 
-Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`和`NSMutableArray`类，他们可以存储任何类型的实例而且不提供他们返回对象的任何本质信息。 在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是`class`类型。例如： 如果我们创建了一个`Int`值类型的数组，我们不能往其中插入任何不是`Int`类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
+Swift 数组对存储数据有具体要求。 不同于 Objective-C 的`NSArray`和`NSMutableArray`类，他们可以存储任何类型的实例而且不提供他们返回对象的任何本质信息。 在 Swift 中，数据值在被存储进入某个数组之前类型必须明确，方法是通过显式的类型标注或类型推断，而且不是必须是`class`类型。例如： 如果我们创建了一个`Int`值类型的数组，我们不能往其中插入任何不是`Int`类型的数据。 Swift 中的数组是类型安全的，并且它们中包含的类型必须明确。
 
+
 ### 数组的简单语法
-写 Swift 数组应该遵循像`Array`这样的形式，其中sometype是这个数组中唯一允许存在的数据类型。 我们也可以使用像`SomeType[]`这样的简单语法。 尽管两种形式在功能上是一样的， 但是我们推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
 
+写 Swift 数组应该遵循像`Array`这样的形式，其中`SomeType`是这个数组中唯一允许存在的数据类型。 我们也可以使用像`SomeType[]`这样的简单语法。 尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。
+
+
 ### 数组构造语句
+
 我们可以使用字面语句来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面语句是一系列由逗号分割并由方括号包含的数值。
 `[value 1, value 2, value 3]`。
 
@@ -30,26 +41,27 @@ Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`
 `shoppingList`变量被声明为“字符串值类型的数组“，记作`String[]`。 因为这个数组被规定只有`String`一种数据结构，所以只有`String`类型可以在其中被存取。 在这里，`shoppinglist`数组由两个`String`值（`"Eggs"` 和`"Milk"`）构造，并且由字面语句定义。
 
 > 注意：
-`Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。
+>
+> `Shoppinglist`数组被声明为变量（`var`关键字创建）而不是常量（`let`创建）是因为以后可能会有更多的数据项被插入其中。
 
 在这个例子中，字面语句仅仅包含两个`String`值。匹配了该数组的变量声明（只能包含`String`的数组），所以这个字面语句的分配过程就是允许用两个初始项来构造`shoppinglist`。
 
-由 于Swift 的类型推断机制，当我们用字面语句构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 `shoppinglist`的构造也可以这样写：
+由于 Swift 的类型推断机制，当我们用字面语句构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 `shoppinglist`的构造也可以这样写：
 
     var shoppingList = ["Eggs", "Milk"]
 
 因为所有字面语句中的值都是相同的类型，Swift 可以推断出`String[]`是`shoppinglist`中变量的正确类型。
 
-
+
 ### 访问和修改数组
 
 我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。
 还可以使用数组的只读属性`count`来获取数组中的数据项数量。
 
     println("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 的捷径。
 
     if shoppingList.isEmpty {
         println("The shopping list is empty.")
@@ -91,7 +103,8 @@ Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`
     // shoppingList 现在有六项
 
 > 注意：
-我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于0时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
+>
+>我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的`count`属性进行比较来在使用某个索引之前先检验是否有效。除了当`count`等于 0 时（说明这是个空数组），最大索引值一直是`count - 1`，因为数组都是零起索引。
 
 调用数组的`insert(atIndex:)`方法来在某个具体索引值之前添加数据项：
 
@@ -99,7 +112,7 @@ Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`
     // shoppingList 现在有7项
     // "Maple Syrup" 现在是这个列表中的第一项
 
-这次`insert`函数调用把值为`"Maple Syrup"`的新数据项插入shopping列表的最开始位置，并且使用`0`作为索引值。
+这次`insert`函数调用把值为`"Maple Syrup"`的新数据项插入列表的最开始位置，并且使用`0`作为索引值。
 
 类似的我们可以使用`removeAtIndex`方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）:
 
@@ -120,6 +133,7 @@ Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`
     // shoppingList现在只有5项，不包括cheese
     //  apples 常量的值现在等于"Apples" 字符串
 
+
 ### 数组的遍历
 
 我们可以使用`for-in`循环来遍历所有数组中的数据项：
@@ -144,8 +158,9 @@ Swift数组对存储数据有具体要求。 不同于 Objective-C的`NSArray`
     // Item 4: Baking Powder
     // Item 5: Bananas
 
-更多关于`for-in`循环的介绍请参见[for循环](待添加链接)。
+更多关于`for-in`循环的介绍请参见[for 循环](05_Control_Flow.html#for_loops)。
 
+
 ### 创建并且构造一个数组
 
 我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
@@ -178,6 +193,7 @@ Swift 中的`Array`类型还提供一个可以创建特定大小并且所有数
     var sixDoubles = threeDoubles + anotherThreeDoubles
     // sixDoubles 被推断为 Double[], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
 
+
 ## 字典
 
 字典是一种存储相同类型多重数据的存储器。每个值（value）都关联独特的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。
@@ -186,8 +202,9 @@ Swift 的字典使用时需要具体规定可以存储键和值类型。不同
 
 Swift 的字典使用`Dictionary`定义,其中`KeyType`是字典中键的数据类型，`ValueType`是字典中对应于这些键所存储值的数据类型。
 
-`KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](链接待添加)）也是默认可哈希的。
+`KeyType`的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如`String`，`Int`， `Double`和`Bool`）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见[枚举](08_Enumerations.html)）也是默认可哈希的。
 
+
 ## 字典字面语句
 
 我们可以使用字典字面语句来构造字典，他们和我们刚才介绍过的数组字面语句拥有相似语法。一个字典字面语句是一个定义拥有一个或者多个键值对的字典集合的简单语句。
@@ -203,7 +220,8 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
 `airports`字典被定义为一种`Dictionary`,它意味着这个字典的键和值都是`String`类型。
 
 > 注意：
-`airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。
+>
+> `airports`字典被声明为变量（用`var`关键字）而不是常量（`let`关键字）因为后来更多的机场信息会被添加到这个示例字典中。
 
 `airports`字典使用字典字面语句初始化，包含两个键值对。第一对的键是`TYO`，值是`Tokyo`。第二对的键是`DUB`，值是`Dublin`。
 
@@ -215,6 +233,7 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
 
 因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出`Dictionary`是`airports`字典的正确类型。
 
+
 ### 读取和修改字典
 
 我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性`count`来获取某个字典的数据项数量：
@@ -222,7 +241,7 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
     println("The dictionary of airports contains \(airports.count) items.")
     // 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
 
-我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的key作为下标索引，并且分配新的合适类型的值：
+我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的 key 作为下标索引，并且分配新的合适类型的值：
 
     airports["LHR"] = "London"
     // airports 字典现在有三个数据项
@@ -239,9 +258,9 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
     if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") {
         println("The old value for DUB was \(oldValue).")
     }
-    // 打印出 "The old value for DUB was Dublin."（dub原值是dublin）
+    // 输出 "The old value for DUB was Dublin."（dub原值是dublin）
 
-我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选 类型返回这个键存在的相关值，否则就返回`nil`：
+我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选类型返回这个键存在的相关值，否则就返回`nil`：
 
     if let airportName = airports["DUB"] {
         println("The name of the airport is \(airportName).")
@@ -264,9 +283,11 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
     } else {
         println("The airports dictionary does not contain a value for DUB.")
     }
-    // 打印 "The removed airport's name is Dublin International."（被移除的机场名字是都柏林国际）
+    // prints "The removed airport's name is Dublin International."
 
+
 ### 字典遍历
+
 我们可以使用`for-in`循环来遍历某个字典中的键值对。每一个字典中的数据项都由`(key, value)`元组形式返回，并且我们可以使用暂时性常量或者变量来分解这些元组：
 
     for (airportCode, airportName) in airports {
@@ -274,7 +295,7 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
     }
     // TYO: Tokyo
     // LHR: London Heathrow
-`for-in`循环请参见[For 循环](链接待添加)。
+`for-in`循环请参见[For 循环](05_Control_Flow.html#for_loops)。
 
 我们也可以通过访问他的`keys`或者`values`属性（都是可遍历集合）检索一个字典的键或者值：
 
@@ -299,8 +320,10 @@ Swift 的字典使用`Dictionary`定义,其中`KeyType`是
     // airportNames is ["Tokyo", "London Heathrow"]
 
 > 注意：
-Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。
+>
+> Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。
 
+
 ### 创建一个空字典
 
 我们可以像数组一样使用构造语法创建一个空字典：
@@ -318,16 +341,19 @@ Swift 的字典类型是无序集合类型。其中字典键，值，键值对
     // namesOfIntegers 又成为了一个 Int, String类型的空字典
 
 > 注意：
-在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见[泛型](链接待添加)。
+>
+> 在后台，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见[泛型](22_Generics.html)。
 
+
 ## 集合的可变性
 
 数组和字典都是在单个集合中存储可变值。如果我们创建一个数组或者字典并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项来改变这个集合的大小。与此相反，如果我们把数组或字典分配成常量，那么他就是不可变的，它的大小不能被改变。
 
 对字典来说，不可变性也意味着我们不能替换其中任何现有键所对应的值。不可变字典的内容在被首次设定之后不能更改。
-不可变行对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。
+不可变行对数组来说有一点不同，当然我们不能试着改变任何不可变数组的大小，但是我们·可以重新设定相对现存索引所对应的值。这使得 Swift 数组在大小被固定的时候依然可以做的很棒。
 
-Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见[Assignment and Copy Behavior for Collection Types](待翻译，链接待添加，请查看对应章节的翻译)。
+Swift 数组的可变性行为同时影响了数组实例如何被分配和修改，想获取更多信息，请参见[集合在赋值和复制中的行为](09_Classes_and_Structures.html#assignment_and_copy_behavior_for_collection_types)。
 
 > 注意：
-在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
+>
+> 在我们不需要改变数组大小的时候创建不可变数组是很好的习惯。如此 Swift 编译器可以优化我们创建的集合。
diff --git a/source/chapter2/05_Control_Flow.md b/source/chapter2/05_Control_Flow.md
index 7d54afca..f5a4adf1 100644
--- a/source/chapter2/05_Control_Flow.md
+++ b/source/chapter2/05_Control_Flow.md
@@ -1,26 +1,43 @@
+> 翻译：vclwei, @coverxit, @NicePiao
+
+> 校对：coverxit
+
 # 控制流
 -----------------
 
-Swift提供了类似C语言的流程控制结构，包括可以多次执行任务的`for`和`while`循环，基于特定条件选择执行不同代码分支的`if`和`switch`语句，还有控制流程跳转到其他代码的`break`和`continue`语句。
+本页包含内容：
 
-除了C里面传统的 `for` 条件递增循环，Swift 还增加了 `for-in` 循环，用来更简单地遍历数组(array)，字典(dictionary)，范围（range），字符串（string）和其他序列类型。
+- [For 循环](#for_loops)
+- [While 循环](#while_loops)
+- [条件语句](#conditional_statement)
 
-Swift 的 `switch` 语句比 C 语言中更加强大。在 C 语言中，如果某个 case 不小心漏写了 `break`，这个 case 就会“掉入”下一个 case，Swift 无需写 `break`，所以不会发生这种“掉入”的情况。Case 还可以匹配更多的类型模式，包括范围（range）匹配，元组（tuple）和特定类型的描述。`switch` case 语句中匹配的值可以是由 case 体内部临时的常量或者变量决定，也可以由 `where` 分句描述更复杂的匹配条件。
-
-##For 循环
-`for` 循环用来按照指定的次数多次执行一系列语句。Swift 提供两种 `for` 循环形式：
-
-* `for-in` 用来遍历一个范围(range)，队列(sequence)，集合(collection)，系列(progression)里面所有的元素执行一系列语句。
-
-* `for` 条件递增语句(`for-condition-increment`)，用来重复执行一系列语句直到特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。
+- [控制传递语句（Control Transfer Statements）](#control_transfer_statements)
 
 
-###For-In
-你可以使用 `for-in` 循环来遍历一个集合里面的所有元素，例如由数字表示的范围、数组中的元素、字符串中的字符。
 
-下面的例子用来输出乘5乘法表前面一部分内容：
+Swift提供了类似 C 语言的流程控制结构，包括可以多次执行任务的`for`和`while`循环，基于特定条件选择执行不同代码分支的`if`和`switch`语句，还有控制流程跳转到其他代码的`break`和`continue`语句。
 
-```
+除了 C 语言里面传统的for条件递增（`for-condition-increment`）循环，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`分句描述更复杂的匹配条件。
+
+
+## For 循环
+
+`for`循环用来按照指定的次数多次执行一系列语句。Swift 提供两种`for`循环形式：
+
+* `for-in`用来遍历一个区间（range），序列（sequence），集合（collection），系列（progression）里面所有的元素执行一系列语句。
+
+* for条件递增（`for-condition-increment`）语句，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。
+
+
+### For-In
+
+你可以使用`for-in`循环来遍历一个集合里面的所有元素，例如由数字表示的区间、数组中的元素、字符串中的字符。
+
+下面的例子用来输出乘 5 乘法表前面一部分内容：
+
+```swift
 for index in 1...5 {
     println("\(index) times 5 is \(index * 5)")
 }
@@ -31,20 +48,17 @@ 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`），之后`println`方法会再执行一次。整个过程会进行到闭区间结尾为止。
 
-上面的例子中，`index` 是一个每次循环遍历开始时被自动赋值的常量。这种情况下，`index` 在使用前不需要声明，只需要将它包含在循环的声明中，就可以对其进行隐式声明，而无需使用 `let` 关键字声明。
+上面的例子中，`index`是一个每次循环遍历开始时被自动赋值的常量。这种情况下，`index`在使用前不需要声明，只需要将它包含在循环的声明中，就可以对其进行隐式声明，而无需使用`let`关键字声明。
 
-```
-注意：
+>注意：
+>
+`index`常量只存在于循环的生命周期里。如果你想在循环完成后访问`index`的值，又或者想让`index`成为一个变量而不是常量，你必须在循环之前自己进行声明。
 
-index 常量只存在于循环的生命周期里。如果你想在循环完成后访问 index 的值，又或者想让 index 成为一个变量而不是常量，你必须在循环之前自己进行声明。
+如果你不需要知道区间内每一项的值，你可以使用下划线（`_`）替代变量名来忽略对值的访问：
 
-```
-
-如果你不需要知道范围内每一项的值，你可以使用下划线（_）替代变量名来忽略对值的访问：
-
-```
+```swift
 let base = 3
 let power = 10
 var answer = 1
@@ -52,13 +66,14 @@ for _ in 1...power {
     answer *= base
 }
 println("\(base) to the power of \(power) is \(answer)")
-// prints "3 to the power of 10 is 59049
+// 输出 "3 to the power of 10 is 59049"
 ```
-这个例子计算 base 这个数的 power 次幂（本例中，是 3 的 10 次幂），从 1 （3 的 0 次幂）开始做 3 的乘法， 进行 10 次，使用 0 到 9 的半闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号 _ （替代循环中的变量）能够忽略具体的值，并且不提供循环遍历时对值的访问。
 
-使用 `for-in` 遍历一个数组所有元素：
+这个例子计算 base 这个数的 power 次幂（本例中，是`3`的`10`次幂），从`1`（`3`的`0`次幂）开始做`3`的乘法， 进行`10`次，使用`0`到`9`的半闭区间循环。这个计算并不需要知道每一次循环中计数器具体的值，只需要执行了正确的循环次数即可。下划线符号`_`（替代循环中的变量）能够忽略具体的值，并且不提供循环遍历时对值的访问。
 
-```
+使用`for-in`遍历一个数组所有元素：
+
+```swift
 let names = ["Anna", "Alex", "Brian", "Jack"]
 for name in names {
     println("Hello, \(name)!")
@@ -68,9 +83,10 @@ for name in names {
 // Hello, Brian!
 // Hello, Jack!
 ```
-你也可以通过遍历一个字典来访问它的键值对(key-value pairs)。遍历字典时，字典的每项元素会以 （key, value）元组的形式返回，你可以在 `for-in` 循环中使用显式的常量名称来解读 （key, value）元组。下面的例子中，字典的键(key)解读为常量 `animalName` ，字典的值会被解读为常量 `legCount` ：
 
-```
+你也可以通过遍历一个字典来访问它的键值对（key-value pairs）。遍历字典时，字典的每项元素会以`(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")
@@ -79,11 +95,12 @@ for (animalName, legCount) in numberOfLegs {
 // ants have 6 legs
 // cats have 4 legs
 ```
-字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。更多数组和字典相关内容，查看[集合类型章节](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/chapter2/04_Collection_Types.html)。
 
-除了数组和字典，你也可以使用 `for-in` 循环来遍历字符串中的字符：
+字典元素的遍历顺序和插入顺序可能不同，字典的内容在内部是无序的，所以遍历元素时不能保证顺序。关于数组和字典，详情参见[集合类型](../chapter2/04_Collection_Types.html)。
 
-```
+除了数组和字典，你也可以使用`for-in`循环来遍历字符串中的字符（`Character`）：
+
+```swift
 for character in "Hello" {
     println(character)
 }
@@ -93,11 +110,13 @@ for character in "Hello" {
 // l
 // o
 ```
-###For条件递增（for-condition-increment）
 
-除了 `for-in` 循环，Swift 提供使用条件判断和递增方法的标准C样式 `for` 循环:
+
+### For条件递增（for-condition-increment）
 
-```
+除了`for-in`循环，Swift 提供使用条件判断和递增方法的标准 C 样式`for`循环:
+
+```swift
 for var index = 0; index < 3; ++index {
     println("index is \(index)")
 }
@@ -105,11 +124,12 @@ for var index = 0; index < 3; ++index {
 // index is 1
 // index is 2
 ```
+
 下面是一般情况下这种循环方式的格式：
 
-```
-for initialization; condition; increment {
-    statements
+```swift
+for `initialization`; `condition`; `increment` {
+    `statements`
 }
 ```
 
@@ -117,24 +137,24 @@ for initialization; condition; increment {
 
 这个循环执行流程如下：
 
-
 1. 循环首次启动时，初始化表达式（_initialization expression_）被调用一次，用来初始化循环所需的所有常量和变量。
-2. 条件表达式（_condition expression_）被调用，如果表达式调用结果为 `false`，循环结束，继续执行 `for` 循环关闭大括号(})之后的代码。如果表达式调用结果为 `true`，则会执行大括号内部的代码（_statements_）。
-3. 执行所有语句（_statements_）之后，执行递增表达式（_increment expression_）。通常会增加或减少计数器的值，或者根据语句（_statements_）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第2步，条件表达式会再次执行。
+2. 条件表达式（_condition expression_）被调用，如果表达式调用结果为`false`，循环结束，继续执行`for`循环关闭大括号
+（`}`）之后的代码。如果表达式调用结果为`true`，则会执行大括号内部的代码（_statements_）。
+3. 执行所有语句（_statements_）之后，执行递增表达式（_increment expression_）。通常会增加或减少计数器的值，或者根据语句（_statements_）输出来修改某一个初始化的变量。当递增表达式运行完成后，重复执行第 2 步，条件表达式会再次执行。
 
 上述描述和循环格式等同于：
 
-```
-initialization
-while condition {
-    statements
-    increment
+```swift
+`initialization`
+while `condition` {
+    `statements`
+    `increment`
 }
 ```
 
-在初始化表达式中声明的常量和变量(比如 var index = 0)只在 `for` 循环的生命周期里有效。如果想在循环结束后访问 index 的值，你必须要在循环生命周期开始前声明 index。
+在初始化表达式中声明的常量和变量（比如`var index = 0`）只在`for`循环的生命周期里有效。如果想在循环结束后访问`index`的值，你必须要在循环生命周期开始前声明`index`。
 
-```
+```swift
 var index: Int
 for index = 0; index < 3; ++index {
     println("index is \(index)")
@@ -143,98 +163,105 @@ for index = 0; index < 3; ++index {
 // index is 1
 // index is 2
 println("The loop statements were executed \(index) times")
-// prints "The loop statements were executed 3 times
+// 输出 "The loop statements were executed 3 times
 ```
-注意 `index` 在循环结束后最终的值是 3 而不是 2。最后一次调用递增表达式 `++index` 会将 `index` 设置为 3，从而导致 `index < 3` 条件为 `false`，并终止循环。
 
-##While 循环
+注意`index`在循环结束后最终的值是`3`而不是`2`。最后一次调用递增表达式`++index`会将`index`设置为`3`，从而导致`index < 3`条件为`false`，并终止循环。
 
-`While` 循环运行一系列语句直到条件变成 `false`。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种 `while` 循环形式：
+
+## While 循环
 
-* `while` 循环，每次在循环开始时计算条件是否符合；
+`while`循环运行一系列语句直到条件变成`false`。这类循环适合使用在第一次迭代前迭代次数未知的情况下。Swift 提供两种`while`循环形式：
 
-* `do-while` 循环，每次在循环结束时计算条件是否符合。
+* `while`循环，每次在循环开始时计算条件是否符合；
 
+* `do-while`循环，每次在循环结束时计算条件是否符合。
+
+
 ###While
 
-`While` 循环从计算单一条件开始。如果条件为 `true`，会重复运行一系列语句，直到条件变为`false`。
+`while`循环从计算单一条件开始。如果条件为`true`，会重复运行一系列语句，直到条件变为`false`。
 
 下面是一般情况下 `while` 循环格式：
 
-```
-while condition {
-    statements
+```swift
+while `condition` {
+    `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)
 
 游戏的规则如下：
 
 * 游戏盘面包括 25 个方格，游戏目标是达到或者超过第 25 个方格；
-* 每一轮，你通过掷一个6边的骰子来确定你移动方块的步数，移动的路线由上图中横向的虚线所示；
+* 每一轮，你通过掷一个 6 边的骰子来确定你移动方块的步数，移动的路线由上图中横向的虚线所示；
 * 如果在某轮结束，你移动到了梯子的底部，可以顺着梯子爬上去；
 * 如果在某轮结束，你移动到了蛇的头部，你会顺着蛇的身体滑下去。
 
-游戏盘面可以使用一个 `Int` 数组来表达。数组的长度由一个 `finalSquare` 常量储存，用来初始化数组和检测最终胜利条件。游戏盘面由 26 个 `Int` 0 值初始化，而不是 25个 （由 0 到 25，一共 26 个）：
+游戏盘面可以使用一个`Int`数组来表达。数组的长度由一个`finalSquare`常量储存，用来初始化数组和检测最终胜利条件。游戏盘面由 26 个 `Int` 0 值初始化，而不是 25 个（由`0`到`25`，一共 26 个）：
 
-```
+```swift
 let finalSquare = 25
 var board = Int[](count: finalSquare + 1, repeatedValue: 0)
 ```
 
-一些方块被设置成有蛇或者梯子的指定值。梯子底部的方块是一个正值，是你可以向上移动，蛇头处的方块是一个负值，会让你向下移动：
+一些方块被设置成有蛇或者梯子的指定值。梯子底部的方块是一个正值，使你可以向上移动，蛇头处的方块是一个负值，会让你向下移动：
 
-```
+```swift
 board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
 board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
 ```
 
-3 号方块是梯子的底部，会让你向上移动到 11 号方格，我们使用 `board[03]` 等于 `+08` 来表示（11 和 3 之间的差值）。使用一元加运算符（+i）是为了和一元减运算符（-i）对称，为了让盘面代码整齐，小于 10 的数字都使用 0 补齐（这些风格上的调整都不是必须的，只是为了让代码看起来更加整洁）。
+3 号方块是梯子的底部，会让你向上移动到 11 号方格，我们使用`board[03]`等于`+08`（来表示`11`和`3`之间的差值）。使用一元加运算符（`+i`）是为了和一元减运算符（`-i`）对称，为了让盘面代码整齐，小于 10 的数字都使用 0 补齐（这些风格上的调整都不是必须的，只是为了让代码看起来更加整洁）。
 
 玩家由左下角编号为 0 的方格开始游戏。一般来说玩家第一次掷骰子后才会进入游戏盘面：
 
-```
+```swift
 var square = 0
 var diceRoll = 0
 while square < finalSquare {
-    // roll the dice
+    // 掷骰子
     if ++diceRoll == 7 { diceRoll = 1 }
-    // move by the rolled amount
+    // 根据点数移动
     square += diceRoll
     if square < board.count {
-        // if we're still on the board, move up or down for a snake or a ladder
+        // 如果玩家还在棋盘上，顺着梯子爬上去或者顺着蛇滑下去
         square += board[square]
     }
 }
 println("Game over!")
 ```
-本例中使用了最简单的方法来模拟掷骰子。 `diceRoll` 的值并不是一个随机数，而是以 0 为初始值，之后每一次 `while` 循环，`diceRoll` 的值使用前置自增操作符(++i)来自增 1 ，然后检测是否超出了最大值。`++diceRoll` 调用完成后，返回值等于 `diceRoll` 自增后的值。任何时候如果 `diceRoll` 的值等于7时，就超过了骰子的最大值，会被重置为 1。所以 `diceRoll` 的取值顺序会一直是 1, 2, 3, 4, 5, 6, 1, 2。
 
-掷完骰子后，玩家向前移动 `diceRoll` 个方格，如果玩家移动超过了第 25 个方格，这个时候游戏结束，相应的，代码会在 ` square` 增加 `board[square]` 的值向前或向后移动（遇到了梯子或者蛇）之前，检测 `square` 的值是否小于 `board` 的 `count` 属性。
+本例中使用了最简单的方法来模拟掷骰子。 `diceRoll`的值并不是一个随机数，而是以`0`为初始值，之后每一次`while`循环，`diceRoll`的值使用前置自增操作符(`++i`)来自增 1 ，然后检测是否超出了最大值。`++diceRoll`调用完成_后_，返回值等于`diceRoll`自增后的值。任何时候如果`diceRoll`的值等于7时，就超过了骰子的最大值，会被重置为`1`。所以`diceRoll`的取值顺序会一直是`1`，`2`，`3`，`4`，`5`，`6`，`1`，`2`。
 
-如果没有这个检测（`square < board.count`），`board[square]` 可能会越界访问 `board` 数组，导致错误。例如如果 `square` 等于 26， 代码会去尝试访问 `board[26]`，超过数组的长度。
+掷完骰子后，玩家向前移动`diceRoll`个方格，如果玩家移动超过了第 25 个方格，这个时候游戏结束，相应地，代码会在`square`增加`board[square]`的值向前或向后移动（遇到了梯子或者蛇）之前，检测`square`的值是否小于`board`的`count`属性。
 
-当本轮 `while` 循环运行完毕，会再检测循环条件是否需要再运行一次循环。如果玩家移动到或者超过第 25 个方格，循环条件结果为 `false`，此时游戏结束。
+如果没有这个检测（`square < board.count`），`board[square]`可能会越界访问`board`数组，导致错误。例如如果`square`等于`26`， 代码会去尝试访问`board[26]`，超过数组的长度。
+
+当本轮`while`循环运行完毕，会再检测循环条件是否需要再运行一次循环。如果玩家移动到或者超过第 25 个方格，循环条件结果为`false`，此时游戏结束。
 
 `while` 循环比较适合本例中的这种情况，因为在 `while` 循环开始时，我们并不知道游戏的长度或者循环的次数，只有在达成指定条件时循环才会结束。
 
+
+
 ###Do-While
-`while` 循环的另外一种形式是 `do-while`，它和 `while` 的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为 `false`。
 
-下面是一般情况下 `do-while` 循环的格式：
+`while`循环的另外一种形式是`do-while`，它和`while`的区别是在判断循环条件之前，先执行一次循环的代码块，然后重复循环直到条件为`false`。
 
-```
+下面是一般情况下 `do-while`循环的格式：
+
+```swift
 do {
-    statements
-} while condition
+    `statements`
+} while `condition`
 ```
 
-还是蛇和梯子的游戏，使用 `do-while` 循环来替代 `while` 循环。`finalSquare`，`board`，`square` 和 `diceRoll` 的值初始化同 `while` 循环一样：
+还是蛇和梯子的游戏，使用`do-while`循环来替代`while`循环。`finalSquare`、`board`、`square`和`diceRoll`的值初始化同`while`循环一样：
 
-```
+``` swift
 let finalSquare = 25
 var board = Int[](count: finalSquare + 1, repeatedValue: 0)
 board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
@@ -243,49 +270,49 @@ var square = 0
 var diceRoll = 0
 ```
 
-`do-while` 的循环版本，循环中第一步就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
+`do-while`的循环版本，循环中_第一步_就需要去检测是否在梯子或者蛇的方块上。没有梯子会让玩家直接上到第 25 个方格，所以玩家不会通过梯子直接赢得游戏。这样在循环开始时先检测是否踩在梯子或者蛇上是安全的。
 
-游戏开始时，玩家在第 0 个方格上，`board[0]` 一直等于 0， 不会有什么影响：
+游戏开始时，玩家在第 0 个方格上，`board[0]`一直等于 0， 不会有什么影响：
 
-```
+```swift
 do {
-    // move up or down for a snake or ladder
+    // 顺着梯子爬上去或者顺着蛇滑下去
     square += board[square]
-    // roll the dice
+    // 掷骰子
     if ++diceRoll == 7 { diceRoll = 1 }
-    // move by the rolled amount
+    // 根据点数移动
     square += diceRoll
 } while square < finalSquare
 println("Game over!")
 ```
 
-检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动 `diceRoll` 个方格，本轮循环结束。
+检测完玩家是否踩在梯子或者蛇上之后，开始掷骰子，然后玩家向前移动`diceRoll`个方格，本轮循环结束。
 
-循环条件（`while square < finalSquare`）和 `while` 方式相同，但是只会在循环结束后进行计算。在这个游戏中，`do-while` 表现得比 `while` 循环更好。 `do-while` 方式会在条件判断 `square` 没有超出后直接运行 `square += board[square]` ，这种方式可以去掉 `while` 版本中的数组越界判断。
+循环条件（`while square < finalSquare`）和`while`方式相同，但是只会在循环结束后进行计算。在这个游戏中，`do-while`表现得比`while`循环更好。`do-while`方式会在条件判断`square`没有超出后直接运行`square += board[square]`，这种方式可以去掉`while`版本中的数组越界判断。
 
 
 ## 条件语句
 
 根据特定的条件执行特定的代码通常是十分有用的，例如：当错误发生时，你可能想运行额外的代码；或者，当输入的值太大或太小时，向用户显示一条消息等。要实现这些功能，你就需要使用*条件语句*。
 
-Swift 提供两种类型的条件语句：`if`语句和`switch`语句。通常，当条件较为简单且可能的情况很少时，使用`if`语句。而`switch`语句更适用于复杂的条件、可能的情况很多且需要用到模式匹配(pattern-matching)的情境。
+Swift 提供两种类型的条件语句：`if`语句和`switch`语句。通常，当条件较为简单且可能的情况很少时，使用`if`语句。而`switch`语句更适用于条件较复杂、可能情况较多且需要用到模式匹配（pattern-matching）的情境。
 
 
 ### If
 
-`if`语句最简单的形式就是只包含一个条件，当且仅当该条件为`真`时，才执行相关代码：
+`if`语句最简单的形式就是只包含一个条件，当且仅当该条件为`true`时，才执行相关代码：
 
 ```swift
 var temperatureInFahrenheit = 30
 if temperatureInFahrenheit <= 32 {
     println("It's very cold. Consider wearing a scarf.")
 }
-// prints "It's very cold. Consider wearing a scarf."
+// 输出 "It's very cold. Consider wearing a scarf."
 ```
 
-上面的例子会判断温度是否小于等于32华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行`if`块后面的代码。
+上面的例子会判断温度是否小于等于 32 华氏度（水的冰点）。如果是，则打印一条消息；否则，不打印任何消息，继续执行`if`块后面的代码。
 
-当然，`if`语句允许二选一，也就是当条件为假时，执行*else语句*：
+当然，`if`语句允许二选一，也就是当条件为`false`时，执行 *else 语句*：
 
 ```swift
 temperatureInFahrenheit = 40
@@ -294,10 +321,10 @@ if temperatureInFahrenheit <= 32 {
 } else {
     println("It's not that cold. Wear a t-shirt.")
 }
-// prints "It's not that cold. Wear a t-shirt."
+// 输出 "It's not that cold. Wear a t-shirt."
 ```
 
-显然，这两条分支中总有一条会被执行。由于温度已升至40华氏度，不算太冷，没必要再围围巾——因此，`else`分支就被触发了。
+显然，这两条分支中总有一条会被执行。由于温度已升至 40 华氏度，不算太冷，没必要再围围巾——因此，`else`分支就被触发了。
 
 你可以把多个`if`语句链接在一起，像下面这样：
 
@@ -310,12 +337,12 @@ if temperatureInFahrenheit <= 32 {
 } else {
     println("It's not that cold. Wear a t-shirt.")
 }
-// prints "It's really warm. Don't forget to wear sunscreen."
+// 输出 "It's really warm. Don't forget to wear sunscreen."
 ```
 
-在上面的例子中，额外的`if`语句用于判断是不是特别热。而最后的*else语句*被保留了下来，用于打印既不冷也不热时的消息。
+在上面的例子中，额外的`if`语句用于判断是不是特别热。而最后的`else`语句被保留了下来，用于打印既不冷也不热时的消息。
 
-实际上，最后的*else语句*是可选的：
+实际上，最后的`else`语句是可选的：
 
 ```swift
 temperatureInFahrenheit = 72
@@ -331,7 +358,7 @@ if temperatureInFahrenheit <= 32 {
 
 ### Switch
 
-`switch`语句会尝试把某个值与若干个模式(pattern)进行匹配。根据第一个匹配成功的模式，`switch`语句会执行对应的代码。当有可能的情况较多时，通常用`switch`语句替换`if`语句。
+`switch`语句会尝试把某个值与若干个模式（pattern）进行匹配。根据第一个匹配成功的模式，`switch`语句会执行对应的代码。当有可能的情况较多时，通常用`switch`语句替换`if`语句。
 
 `switch`语句最简单的形式就是把某个值与一个或若干个相同类型的值作比较：
 
@@ -347,11 +374,11 @@ default:
 }
 ```
 
-`switch`语句都由多个*case*构成。为了匹配某些更特定的值，Swift 提供了几种更复杂的匹配模式，这些模式将在本节的稍后部分提到。
+`switch`语句都由*多个 case* 构成。为了匹配某些更特定的值，Swift 提供了几种更复杂的匹配模式，这些模式将在本节的稍后部分提到。
 
-每一个*case*都是代码执行的一条分支，这与`if`语句类似。与之不同的是，`switch`语句会决定哪一条分支应该被执行。
+每一个 case 都是代码执行的一条分支，这与`if`语句类似。与之不同的是，`switch`语句会决定哪一条分支应该被执行。
 
-`switch`语句必须是完备的。这就是说，每一个可能的值都必须至少有一个*case*块与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认(`default`)块满足该要求，这个默认块必须在`switch`语句的最后面。
+`switch`语句必须是_完备的_。这就是说，每一个可能的值都必须至少有一个 case 分支与之对应。在某些不可能涵盖所有值的情况下，你可以使用默认（`default`）分支满足该要求，这个默认分支必须在`switch`语句的最后面。
 
 下面的例子使用`switch`语句来匹配一个名为`someCharacter`的小写字符：
 
@@ -366,20 +393,23 @@ case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
 default:
     println("\(someCharacter) is not a vowel or a consonant")
 }
-// prints "e is a vowel"
+// 输出 "e is a vowel"
 ```
 
-在这个例子中，第一个*case*块用于匹配五个元音，第二个*case*块用于匹配所有的辅音。
+在这个例子中，第一个 case 分支用于匹配五个元音，第二个 case 分支用于匹配所有的辅音。
 
-由于为其它可能的字符写*case*快没有实际的意义，因此在这个例子中使用了默认块来处理剩下的既不是元音也不是辅音的字符——这就保证了`switch`语句的完备性。
+由于为其它可能的字符写 case 分支没有实际的意义，因此在这个例子中使用了默认分支来处理剩下的既不是元音也不是辅音的字符——这就保证了`switch`语句的完备性。
 
-#### 不存在隐式的贯穿(Fallthrough)
+
+#### 不存在隐式的贯穿（No Implicit Fallthrough）
 
-与C语言和Objective-C中的`switch`语句不同，在 Swift 中，当匹配的*case*块中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个*case*块。这也就是说，不需要在*case*块中显式地使用`break`语句。这使得`switch`语句更安全、更易用，也避免了因忘记写`break`语句而产生的错误。
+与 C 语言和 Objective-C 中的`switch`语句不同，在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止`switch`语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用`break`语句。这使得`switch`语句更安全、更易用，也避免了因忘记写`break`语句而产生的错误。
 
-> 注意：你依然可以在*case*块中的代码执行完毕前跳出，详情请参考[Switch 语句中的 Break`待添加链接`]()
+> 注意：
+>
+你依然可以在 case 分支中的代码执行完毕前跳出，详情请参考[Switch 语句中的 break](#break_in_a_switch_statement)。
 
-每一个*case*块都*必须*包含至少一条语句。像下面这样书写代码是无效的，因为第一个*case*块是空的：
+每一个 case 分支都*必须*包含至少一条语句。像下面这样书写代码是无效的，因为第一个 case 分支是空的：
 
 ```swift
 let anotherCharacter: Character = "a"
@@ -393,9 +423,9 @@ default:
 // this will report a compile-time error
 ```
 
-不像C语言里的`switch`语句，在 Swift 中，`switch`语句不会同时匹配`"a"`和`"A"`。相反的，上面的代码会引起编译期错误：`case "a": does not contain any executable statements`——这就避免了意外地从一个*case*块贯穿到另外一个，使得代码更安全、也更直观。
+不像 C 语言里的`switch`语句，在 Swift 中，`switch`语句不会同时匹配`"a"`和`"A"`。相反的，上面的代码会引起编译期错误：`case "a": does not contain any executable statements`——这就避免了意外地从一个 case 分支贯穿到另外一个，使得代码更安全、也更直观。
 
-一个*case*也可以包含多个模式，用逗号把它们分开（如果太长了也可以分行写）：
+一个 case 也可以包含多个模式，用逗号把它们分开（如果太长了也可以分行写）：
 
 ```swift
 switch `some value to consider` {
@@ -405,11 +435,13 @@ case `value 1`,
 }
 ```
 
-> 注意：如果想要贯穿特定的*case*块中，请使用`fallthrough`语句，详情请参考[贯穿 (Fallthrough)`待添加链接`]()
+> 注意：
+如果想要贯穿至特定的 case 分支中，请使用`fallthrough`语句，详情请参考[贯穿（Fallthrough）](#fallthrough)。
 
-#### 范围匹配
+
+#### 区间匹配（Range Matching）
 
-*case*块的模式也可以是一个值的范围。下面的例子展示了如何使用范围匹配来输出任意数字对应的自然语言格式：
+case 分支的模式也可以是一个值的区间。下面的例子展示了如何使用区间匹配来输出任意数字对应的自然语言格式：
 
 ```swift
 let count = 3_000_000_000_000
@@ -432,12 +464,13 @@ default:
     naturalCount = "millions and millions of"
 }
 println("There are \(naturalCount) \(countedThings).")
-// prints "There are millions and millions of stars in the Milky Way."
+// 输出 "There are millions and millions of stars in the Milky Way."
 ```
 
-#### 元组 (Tuple)
+
+#### 元组（Tuple）
 
-你可以使用元组在同一个`switch`语句中测试多个值。元组中的元素可以是值，也可以是范围。另外，使用下划线(_)来匹配所有可能的值。
+你可以使用元组在同一个`switch`语句中测试多个值。元组中的元素可以是值，也可以是区间。另外，使用下划线（`_`）来匹配所有可能的值。
 
 下面的例子展示了如何使用一个`(Int, Int)`类型的元组来分类下图中的点(x, y)：
 
@@ -455,18 +488,20 @@ case (-2...2, -2...2):
 default:
     println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
 }
-// prints "(1, 1) is inside the box"
+// 输出 "(1, 1) is inside the box"
 ```
 
-
+![image](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/coordinateGraphSimple_2x.png)
 
 在上面的例子中，`switch`语句会判断某个点是否是原点(0, 0)，是否在红色的x轴上，是否在黄色y轴上，是否在一个以原点为中心的4x4的矩形里，或者在这个矩形外面。
 
-不像C语言，Swift 允许多个*case*匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有*四个case*。但是，如果存在多个匹配，那么只会执行第一个被匹配到的*case*块。考虑点(0, 0)会首先匹配`case (0, 0)`，因此剩下的能够匹配(0, 0)的*case*块都会被忽视掉。
+不像 C 语言，Swift 允许多个 case 匹配同一个值。实际上，在这个例子中，点(0, 0)可以匹配所有_四个 case_。但是，如果存在多个匹配，那么只会执行第一个被匹配到的 case 分支。考虑点(0, 0)会首先匹配`case (0, 0)`，因此剩下的能够匹配(0, 0)的 case 分支都会被忽视掉。
 
-#### 值绑定 (Value Bindings)
 
-*case*块的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该*case*块里就可以被引用了——这种行为被称为*值绑定*。
+
+#### 值绑定（Value Bindings）
+
+case 分支的模式允许将匹配的值绑定到一个临时的常量或变量，这些常量或变量在该 case 分支里就可以被引用了——这种行为被称为*值绑定*（value binding）。
 
 下面的例子展示了如何在一个`(Int, Int)`类型的元组中使用值绑定来分类下图中的点(x, y)：
 
@@ -480,24 +515,25 @@ case (0, let y):
 case let (x, y):
     println("somewhere else at (\(x), \(y))")
 }
-// prints "on the x-axis with an x value of 2"
+// 输出 "on the x-axis with an x value of 2"
 ```
 
-
+![image](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/coordinateGraphMedium_2x.png)
 
 在上面的例子中，`switch`语句会判断某个点是否在红色的x轴上，是否在黄色y轴上，或者不在坐标轴上。
 
-这三个*case*都声明了常量`x`和`y`的占位符，用于临时获取元组`anotherPoint`的一个或两个值。第一个*case*——`case (let x, 0)`将匹配一个纵坐标为`0`的点，并把这个点的横坐标赋给临时的常量`x`。类似的，第二个*case*——`case (0, let y)`将匹配一个横坐标为`0`的点，并把这个点的纵坐标赋给临时的常量`y`。
+这三个 case 都声明了常量`x`和`y`的占位符，用于临时获取元组`anotherPoint`的一个或两个值。第一个 case ——`case (let x, 0)`将匹配一个纵坐标为`0`的点，并把这个点的横坐标赋给临时的常量`x`。类似的，第二个 case ——`case (0, let y)`将匹配一个横坐标为`0`的点，并把这个点的纵坐标赋给临时的常量`y`。
 
-一旦声明了这些临时的常量，它们就可以在其对应的*case*块里引用。在这个例子中，它们用于简化`println`的书写。
+一旦声明了这些临时的常量，它们就可以在其对应的 case 分支里引用。在这个例子中，它们用于简化`println`的书写。
 
-请注意，这个`switch`语句不包含默认块。这是因为最后一个*case*——`case let(x, y)`声明了一个可以匹配余下所有值的元组。这使得`switch`语句已经完备了，因此不需要再书写默认块。
+请注意，这个`switch`语句不包含默认分支。这是因为最后一个 case ——`case let(x, y)`声明了一个可以匹配余下所有值的元组。这使得`switch`语句已经完备了，因此不需要再书写默认分支。
 
-在上面的例子中，`x`和`y`是常量，这是因为没有必要在其对应的*case*块中修改它们的值。然而，它们也可以是变量——程序将会创建临时变量，并用相应的值初始化它。修改这些变量只会影响其对应的*case*块。
+在上面的例子中，`x`和`y`是常量，这是因为没有必要在其对应的 case 分支中修改它们的值。然而，它们也可以是变量——程序将会创建临时变量，并用相应的值初始化它。修改这些变量只会影响其对应的 case 分支。
 
+
 #### Where
 
-*case*块的模式可以使用`where`语句来判断额外的条件。
+case 分支的模式可以使用`where`语句来判断额外的条件。
 
 下面的例子把下图中的点(x, y)进行了分类：
 
@@ -511,18 +547,19 @@ case let (x, y) where x == -y:
 case let (x, y):
     println("(\(x), \(y)) is just some arbitrary point")
 }
-// prints "(1, -1) is on the line x == -y"
+// 输出 "(1, -1) is on the line x == -y"
 ```
 
-
+![image](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/coordinateGraphComplex_2x.png)
 
 在上面的例子中，`switch`语句会判断某个点是否在绿色的对角线`x == y`上，是否在紫色的对角线`x == -y`上，或者不在对角线上。
 
-这三个*case*都声明了常量`x`和`y`的占位符，用于临时获取元组`yetAnotherPoint`的两个值。这些常量被用作`where`语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当`where`语句的条件为`真`时，匹配到的*case*块才会被执行。
+这三个 case 都声明了常量`x`和`y`的占位符，用于临时获取元组`yetAnotherPoint`的两个值。这些常量被用作`where`语句的一部分，从而创建一个动态的过滤器(filter)。当且仅当`where`语句的条件为`true`时，匹配到的 case 分支才会被执行。
 
-就像是值绑定中的例子，由于最后一个*case*块匹配了余下所有可能的值，`switch`语句就已经完备了，因此不需要再书写默认块。
+就像是值绑定中的例子，由于最后一个 case 分支匹配了余下所有可能的值，`switch`语句就已经完备了，因此不需要再书写默认分支。
 
-## 控制转移语句
+
+## 控制传递语句（Control Transfer Statements）
 
 控制转移语句改变你代码的执行顺序，通过它你可以实现代码的跳转。Swift有四种控制转移语句。
 
@@ -531,151 +568,177 @@ case let (x, y):
 -   fallthrough
 -   return
 
-我们将会在下面讨论`continue` ,`break`,和`fallthrough`语句。`return`语句将会在[函数](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/chapter2/06_Functions.html)章节讨论。
+我们将会在下面讨论`continue`、`break`和`fallthrough`语句。`return`语句将会在[函数](../chapter2/06_Functions.html)章节讨论。
 
+
+### Continue
 
-###Continue
+`continue`语句告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。就好像在说“本次循环迭代我已经执行完了”，但是并不会离开整个循环体。
 
-`continue`告诉一个循环体立刻停止本次循环迭代，重新开始下次循环迭代。就好像在说“本次循环迭代我已经执行完了”，但是并不会离开整个循环体。
-
->__NOTE__
-在一个`for-condition-increment `循环体中，在调用`continue`语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
+>注意：
+>
+在一个for条件递增（`for-condition-increment`）循环体中，在调用`continue`语句后，迭代增量仍然会被计算求值。循环体继续像往常一样工作，仅仅只是循环体中的执行代码会被跳过。
 
 下面的例子把一个小写字符串中的元音字母和空格字符移除，生成了一个含义模糊的短句：
 
-    let puzzleInput = "great minds think alike"
-    var puzzleOutput = ""
-    for character in puzzleInput {
-        switch character {
-        case "a", "e", "i", "o", "u", " ":
-            continue
-        default:
+```swift
+let puzzleInput = "great minds think alike"
+var puzzleOutput = ""
+for character in puzzleInput {
+    switch character {
+    case "a", "e", "i", "o", "u", " ":
+        continue
+    default:
         puzzleOutput += character
-        }
     }
-    println(puzzleOutput)
-    // prints "grtmndsthnklk"
+}
+println(puzzleOutput)
+    // 输出 "grtmndsthnklk"
+```
 
 在上面的代码中，只要匹配到元音字母或者空格字符，就调用`continue`语句，使本次循环迭代结束，从新开始下次循环迭代。这种行为使`switch`匹配到元音字母和空格字符时不做处理，而不是让每一个匹配到的字符都被打印。
 
+
+### Break
 
-###Break
 `break`语句会立刻结束整个控制流的执行。当你想要更早的结束一个`switch`代码块或者一个循环体时，你都可以使用`break`语句。
 
-####在循环体中使用Break
-当在一个循环体中使用`break`时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(})后的第一行代码。不会再有本次循环迭代的代码被执行，也不会再有下次的循环迭代产生。
+
+#### 循环语句中的 break
 
-####在Switch代码块中使用Break
-当在一个`switch`代码块中使用`break`时，会立即中断该`switch`代码块的执行，并且跳转到表示`switch`代码块结束的大括号(})后的第一行代码。
+当在一个循环体中使用`break`时，会立刻中断该循环体的执行，然后跳转到表示循环体结束的大括号(`}`)后的第一行代码。不会再有本次循环迭代的代码被执行，也不会再有下次的循环迭代产生。
 
-这种特性可以被用来匹配或者忽略一个或多个分支。因为Swift语言的`switch`需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上`break`语句。当那个分支被匹配到时，分支内的`break`语句立即结束`switch`代码块。
->__NOTE__
+
+#### Switch 语句中的 break
+
+当在一个`switch`代码块中使用`break`时，会立即中断该`switch`代码块的执行，并且跳转到表示`switch`代码块结束的大括号(`}`)后的第一行代码。
+
+这种特性可以被用来匹配或者忽略一个或多个分支。因为 Swift 的`switch`需要包含所有的分支而且不允许有为空的分支，有时为了使你的意图更明显，需要特意匹配或者忽略某个分支。那么当你想忽略某个分支时，可以在该分支内写上`break`语句。当那个分支被匹配到时，分支内的`break`语句立即结束`switch`代码块。
+
+>注意：
+>
 当一个`switch`分支仅仅包含注释时，会被报编译时错误。注释不是代码语句而且也不能让`switch`分支达到被忽略的效果。你总是可以使用`break`来忽略某个分支。
 
 下面的例子通过`switch`来判断一个`Character`值是否代表下面四种语言之一。为了简洁，多个值被包含在了同一个分支情况中。
 
-    let numberSymbol: Character = "三"  // Simplified Chinese for the number 3
-    possibleIntegerValue: Int?
-    switch numberSymbol {
-    case "1", "?", "一", "?":
-        possibleIntegerValue = 1
-    case "2", "?", "二", "?":
-        possibleIntegerValue = 2
-    case "3", "?", "三", "?":
-        possibleIntegerValue = 3
-    case "4", "?", "四", "?":
-        possibleIntegerValue = 4
-    default:
-        break
-    }
-    if let integerValue = possibleIntegerValue {
-        println("The integer value of \(numberSymbol) is \(integerValue).")
-    } else {
-        println("An integer value could not be found for \(numberSymbol).")
-    }
-    // prints "The integer value of 三 is 3."
+```swift
+let numberSymbol: Character = "三"  // 简体中文里的数字 3
+var possibleIntegerValue: Int?
+switch numberSymbol {
+case "1", "١", "一", "๑":
+    possibleIntegerValue = 1
+case "2", "٢", "二", "๒":
+    possibleIntegerValue = 2
+case "3", "٣", "三", "๓":
+    possibleIntegerValue = 3
+case "4", "٤", "四", "๔":
+    possibleIntegerValue = 4
+default:
+    break
+}
+if let integerValue = possibleIntegerValue {
+    println("The integer value of \(numberSymbol) is \(integerValue).")
+} else {
+    println("An integer value could not be found for \(numberSymbol).")
+}
+// 输出 "The integer value of 三 is 3."
+```
 
-这个例子检查`numberSymbol`是否是拉丁，阿拉伯，中文或者泰语中的1...4之一。如果被匹配到，该`switch`分支语句给`Int?`类型变量`possibleIntegerValue`设置一个整数值。
+这个例子检查`numberSymbol`是否是拉丁，阿拉伯，中文或者泰语中的`1`到`4`之一。如果被匹配到，该`switch`分支语句给`Int?`类型变量`possibleIntegerValue`设置一个整数值。
 
-当`switch`代码块执行完后，接下来的代码通过使用可选绑定来判断'possibleIntegerValue'是否曾经被设置过值。因为是可选类型的缘故，'possibleIntegerValue'有一个隐式的初始值`nil`，所以仅仅当`possibleIntegerValue`曾被`switch`代码块的前四个分支中的某个设置过一个值时，可选的绑定将会被判定为成功。
+当`switch`代码块执行完后，接下来的代码通过使用可选绑定来判断`possibleIntegerValue`是否曾经被设置过值。因为是可选类型的缘故，`possibleIntegerValue`有一个隐式的初始值`nil`，所以仅仅当`possibleIntegerValue`曾被`switch`代码块的前四个分支中的某个设置过一个值时，可选的绑定将会被判定为成功。
 
-在上面的例子中，想要把`Character`所有的的可能性都枚举出来是不现实的，所以使用`default`分支来包含所有上面没有匹配到字符的情况。由于这个`default`分支不需要执行任何动作，所以它只写了一条`break`语句。一旦落入到`default`分支中后，`break`语句就完成了该分支的所有代码操作，代码继续向下,开始执行`if let`语句。
+在上面的例子中，想要把`Character`所有的的可能性都枚举出来是不现实的，所以使用`default`分支来包含所有上面没有匹配到字符的情况。由于这个`default`分支不需要执行任何动作，所以它只写了一条`break`语句。一旦落入到`default`分支中后，`break`语句就完成了该分支的所有代码操作，代码继续向下，开始执行`if let`语句。
 
-###Fallthrough
-Swift语言中的`switch`不会从上一个`case`分支落入到下一个`case`分支中。相反，只要第一个匹配到的`case`分支完成了它需要执行的语句，整个`switch`代码块完成了它的执行。相比之下，C语言要求你显示的插入`break`语句到每个`switch`分支的末尾来阻止自动落入到下一个`case`分支中。Swift语言的这种避免默认落入到下一个分支中的特性意味着它的`switch` 功能要比C语言的更加清晰和可预测，可以避免无意识地执行多个`case`分支从而引发的错误。
+
+### 贯穿（Fallthrough）
 
-如果你确实需要C风格的落入(fallthrough)的特性，你可以在每个需要该特性的`case`分支中使用`fallthrough`关键字。下面的例子使用`fallthrough`来创建一个数字的描述语句。
+Swift 中的`switch`不会从上一个 case 分支落入到下一个 case 分支中。相反，只要第一个匹配到的 case 分支完成了它需要执行的语句，整个`switch`代码块完成了它的执行。相比之下，C 语言要求你显示的插入`break`语句到每个`switch`分支的末尾来阻止自动落入到下一个 case 分支中。Swift 的这种避免默认落入到下一个分支中的特性意味着它的`switch` 功能要比 C 语言的更加清晰和可预测，可以避免无意识地执行多个 case 分支从而引发的错误。
 
-    let integerToDescribe = 5
-    var description = "The number \(integerToDescribe) is"
-    switch integerToDescribe {
-    case 2, 3, 5, 7, 11, 13, 17, 19:
-        description += " a prime number, and also"
-        fallthrough
-    default:
-        description += " an integer."
-    }
-    println(description)
-    // prints "The number 5 is a prime number, and also an integer."
+如果你确实需要 C 风格的贯穿（fallthrough）的特性，你可以在每个需要该特性的 case 分支中使用`fallthrough`关键字。下面的例子使用`fallthrough`来创建一个数字的描述语句。
 
-这个例子定义了一个`String`类型的变量`description`并且给它设置了一个初始值。函数使用`switch`逻辑来判断`integerToDescribe`变量的值。当`integerToDescribe`的值属于列表中的质数之一时，该函数添加一段文字在`description`后，来表明这个是数字是一个质数。然后它使用`fallthrough`关键字来"落入"到`default`分支中。`default`分支添加一段额外的文字在`description`的最后,至此`switch`代码块执行完了。
+```swift
+let integerToDescribe = 5
+var description = "The number \(integerToDescribe) is"
+switch integerToDescribe {
+case 2, 3, 5, 7, 11, 13, 17, 19:
+    description += " a prime number, and also"
+    fallthrough
+default:
+    description += " an integer."
+}
+println(description)
+// 输出 "The number 5 is a prime number, and also an integer."
+```
+
+这个例子定义了一个`String`类型的变量`description`并且给它设置了一个初始值。函数使用`switch`逻辑来判断`integerToDescribe`变量的值。当`integerToDescribe`的值属于列表中的质数之一时，该函数添加一段文字在`description`后，来表明这个是数字是一个质数。然后它使用`fallthrough`关键字来“贯穿”到`default`分支中。`default`分支添加一段额外的文字在`description`的最后，至此`switch`代码块执行完了。
 
 如果`integerToDescribe`的值不属于列表中的任何质数，那么它不会匹配到第一个`switch`分支。而这里没有其他特别的分支情况，所以`integerToDescribe`匹配到包含所有的`default`分支中。
 
 当`switch`代码块执行完后，使用`println`函数打印该数字的描述。在这个例子中，数字`5`被准确的识别为了一个质数。
->__NOTE__
-`fallthrough`关键字不会检查它下一个将会落入执行的`case`中的匹配条件。`fallthrough`简单地使代码执行继续连接到下一个`case`中的执行代码，这和C语言标准中的`switch`语句特性是一样的。
 
-###Labeled Statements
-在Swift语言中，你可以在循环体和`switch`代码块中嵌套循环体和`switch`代码块来创造复杂的控制流结构。然而，循环体和`switch`代码块两者都可以使用`break`语句来提前结束整个方法体。因此，显示地指明`break`语句想要终止的是哪个循环体或者`switch`代码块,会很有用。类似地，如果你有许多嵌套的循环体，显示指明`continue`语句想要影响哪一个循环体也会非常有用。
+>注意：
+>
+`fallthrough`关键字不会检查它下一个将会落入执行的 case 中的匹配条件。`fallthrough`简单地使代码执行继续连接到下一个 case 中的执行代码，这和 C 语言标准中的`switch`语句特性是一样的。
+
+
+### 带标签的语句（Labeled Statements）
+
+在 Swift 中，你可以在循环体和`switch`代码块中嵌套循环体和`switch`代码块来创造复杂的控制流结构。然而，循环体和`switch`代码块两者都可以使用`break`语句来提前结束整个方法体。因此，显示地指明`break`语句想要终止的是哪个循环体或者`switch`代码块，会很有用。类似地，如果你有许多嵌套的循环体，显示指明`continue`语句想要影响哪一个循环体也会非常有用。
 
 为了实现这个目的，你可以使用标签来标记一个循环体或者`switch`代码块，当使用`break`或者`continue`时，带上这个标签，可以控制该标签代表对象的中断或者执行。
 
 产生一个带标签的语句是通过在该语句的关键词的同一行前面放置一个标签，并且该标签后面还需带着一个冒号。下面是一个`while`循环体的语法，同样的规则适用于所有的循环体和`switch`代码块。
 
-    label name: while condition {
-        statements
-    }
+```
+`label name`: while `condition` {
+    `statements`
+}
+```
 
-下面的例子是在一个带有标签的`while`循环体中调用`break`和`continue`语句，该循环体是上述章节中蛇梯棋游戏的改编版本。这次，游戏增加了一条额外的规则：
+下面的例子是在一个带有标签的`while`循环体中调用`break`和`continue`语句，该循环体是前面章节中_蛇和梯子_的改编版本。这次，游戏增加了一条额外的规则：
 
-- 为了获胜，你必须刚好落在方格25中。
+- 为了获胜，你必须_刚好_落在第 25 个方块中。
 
-如果某次掷骰子使你的移动超出方格25，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在方格25中。
+如果某次掷骰子使你的移动超出第 25 个方块，你必须重新掷骰子，直到你掷出的骰子数刚好使你能落在第 25 个方块中。
 
 游戏的棋盘和之前一样：
 
 ![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`的初始化也和之前一样：
 
-    let finalSquare = 25
-    var board = Int[](count: finalSquare + 1, repeatedValue: 0)
-    board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
-    board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
-    var square = 0
-    var diceRoll = 0
+```swift
+let finalSquare = 25
+var board = Int[](count: finalSquare + 1, repeatedValue: 0)
+board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
+board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
+var square = 0
+var diceRoll = 0
+```
 
-这个版本的游戏使用`while`循环体和`switch`方法块来实现游戏的逻辑。`while`循环体有一个标签名`gameLoop`，来表明它是蛇梯棋游戏的主循环。
+这个版本的游戏使用`while`循环体和`switch`方法块来实现游戏的逻辑。`while`循环体有一个标签名`gameLoop`，来表明它是蛇与梯子的主循环。
 
-该`while`循环体的条件判断语句是`while square !=finalSquare`,这表明你必须刚好落在方格25中。
+该`while`循环体的条件判断语句是`while square !=finalSquare`，这表明你必须刚好落在方格25中。
 
-    gameLoop: while square != finalSquare {
-        if ++diceRoll == 7 { diceRoll = 1 }
-        switch square + diceRoll {
-        case finalSquare:
-            // diceRoll will move us to the final square, so the game is over
-            break gameLoop
-        case let newSquare where newSquare > finalSquare:
-            // diceRoll will move us beyond the final square, so roll again
-            continue gameLoop
-        default:
-            // this is a valid move, so find out its effect
-            square += diceRoll
-            square += board[square]
-        }
+```swift
+gameLoop: while square != finalSquare {
+    if ++diceRoll == 7 { diceRoll = 1 }
+    switch square + diceRoll {
+    case finalSquare:
+        // 到达最后一个方块，游戏结束
+        break gameLoop
+    case let newSquare where newSquare > finalSquare:
+        // 超出最后一个方块，再掷一次骰子
+        continue gameLoop
+    default:
+        // 本次移动有效
+        square += diceRoll
+        square += board[square]
     }
-    println("Game over!")
+}
+println("Game over!")
+```
 
 每次循环迭代开始时掷骰子。与之前玩家掷完骰子就立即移动不同，这里使用了`switch`来考虑每次移动可能产生的结果，从而决定玩家本次是否能够移动。
 
@@ -685,7 +748,7 @@ Swift语言中的`switch`不会从上一个`case`分支落入到下一个`case`
 
 - 在剩余的所有情况中，骰子数产生的都是合法的移动。玩家向前移动骰子数个方格，然后游戏逻辑再处理玩家当前是否处于蛇头或者梯子的底部。本次循环迭代结束，控制跳转到`while`循环体的条件判断语句处，再决定是否能够继续执行下次循环迭代。
 
->__NOTE__
+>注意：
+>
 如果上述的`break`语句没有使用`gameLoop`标签，那么它将会中断`switch`代码块而不是`while`循环体。使用`gameLoop`标签清晰的表明了`break`想要中断的是哪个代码块。
 同时请注意，当调用`continue gameLoop`去跳转到下一次循环迭代时，这里使用`gameLoop`标签并不是严格必须的。因为在这个游戏中，只有一个循环体，所以`continue`语句会影响到哪个循环体是没有歧义的。然而，`continue`语句使用`gameLoop`标签也是没有危害的。这样做符合标签的使用规则，同时参照旁边的`break gameLoop`，能够使游戏的逻辑更加清晰和易于理解。
-
diff --git a/source/chapter2/06_Functions.md b/source/chapter2/06_Functions.md
index f66c668c..9de8a51a 100644
--- a/source/chapter2/06_Functions.md
+++ b/source/chapter2/06_Functions.md
@@ -1,34 +1,38 @@
+> 翻译：honghaoz
+
+> 校对：LunaticM
+
 # 函数（Functions）
 -----------------
 
 本页包含内容：
 
--   函数定义与调用
--   函数参数与返回值
--   函数参数名称
--   函数类型
--   函数嵌套
+-   [函数定义与调用（Defining and Calling Functions）](#Defining_and_Calling_Functions)
+-   [函数参数与返回值（Function Parameters and Return Values）](#Function_Parameters_and_Return_Values)
+-   [函数参数名称（Function Parameter Names）](#Function_Parameter_Names)
+-   [函数类型（Function Types）](#Function_Types)
+-   [函数嵌套（Nested Functions）](#Nested_Functions)
 
 函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标示函数做什么，并且当函数需要执行的时候，这个名字会被“调用”。
 
-Swift统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的C风格函数，到复杂的带局部和外部参数名的Objective-C风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。
-
-在Swift中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
+Swift 统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。
 
+在 Swift 中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。
+
 ## 函数的定义与调用（Defining and Calling Functions）
 
 当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入（称为参数，parameters），也可以定义某种类型的值作为函数执行结束的输出（称为返回类型）。
 
 每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，你用函数名“调用”，并传给它匹配的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。
 
-在下面例子中的函数叫做`"greetingForPerson"`，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做`personName`的`String`值，和一个包含给这个人问候语的`String`类型的返回值：
+在下面例子中的函数叫做`"greetingForPerson"`，之所以叫这个名字是因为这个函数用一个人的名字当做输入，并返回给这个人的问候语。为了完成这个任务，你定义一个输入参数-一个叫做 `personName` 的 `String` 值，和一个包含给这个人问候语的 `String` 类型的返回值：
 
     func sayHello(personName: String) -> String {
         let greeting = "Hello, " + personName + "!"
         return greeting
     }
 
-所有的这些信息汇总起来成为函数的定义，并以`func`作为前缀。指定函数返回类型时，用返回箭头`->`（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。
+所有的这些信息汇总起来成为函数的定义，并以 `func` 作为前缀。指定函数返回类型时，用返回箭头 `->`（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。
 
 该定义描述了函数做什么，它期望接收什么和执行结束时它返回的结果是什么。这样的定义使的函数可以在别的地方以一种清晰的方式被调用：
 
@@ -37,11 +41,11 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     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"`调用的结果，该函数分别返回了不同的结果。
 
 为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：
 
@@ -50,7 +54,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     }
     println(sayHelloAgain("Anna"))
     // prints "Hello again, Anna!
-
+
 ## 函数参数与返回值（Function Parameters and Return Values）
 
 函数参数与返回值在Swift中极为灵活。你可以定义任何类型的函数，包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。
@@ -69,7 +73,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 
 ### 无参函数（Functions Without Parameters）
 
-函数可以没有参数。下面这个函数就是一个无参函数，当被调用时，它返回固定的`String`消息：
+函数可以没有参数。下面这个函数就是一个无参函数，当被调用时，它返回固定的 `String` 消息：
 
     func sayHelloWorld() -> String {
         return "hello, world"
@@ -81,7 +85,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 
 ### 无返回值函数（Functions Without Return Values）
 
-函数可以没有返回值。下面是`sayHello`函数的另一个版本，叫`waveGoodbye`，这个函数直接输出`String`值，而不是返回它：
+函数可以没有返回值。下面是 `sayHello` 函数的另一个版本，叫 `waveGoodbye`，这个函数直接输出 `String` 值，而不是返回它：
 
     func sayGoodbye(personName: String) {
         println("Goodbye, \(personName)!")
@@ -92,7 +96,8 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。
 
 > 注意：
-> 严格上来说，虽然没有返回值被定义，`sayGoodbye`函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫`Void`。它其实是一个空的元组（tuple），没有任何元素，可以写成`()`。
+>
+> 严格上来说，虽然没有返回值被定义，`sayGoodbye` 函数依然返回了值。没有定义返回类型的函数会返回特殊的值，叫 `Void`。它其实是一个空的元组（tuple），没有任何元素，可以写成`()`。
 
 被调用时，一个函数的返回值可以被忽略：
 
@@ -108,16 +113,17 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     printWithoutCounting("hello, world")
     // prints "hello, world" but does not return a value
 
-第一个函数`printAndCount`，输出一个字符串并返回`Int`类型的字符数。第二个函数`printWithoutCounting`调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
+第一个函数 `printAndCount`，输出一个字符串并返回 `Int` 类型的字符数。第二个函数 `printWithoutCounting`调用了第一个函数，但是忽略了它的返回值。当第二个函数被调用时，消息依然会由第一个函数输出，但是返回值不会被用到。
 
 > 注意：
+>
 > 返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，这叫导致编译错误（compile-time error）。
 
 ### 多重返回值函数（Functions with Multiple Return Values）
 
 你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。
 
-下面的这个例子中，`count`函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。
+下面的这个例子中，`count` 函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。
 
     func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
         var vowels = 0, consonants = 0, others = 0
@@ -135,15 +141,15 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         return (vowels, consonants, others)
     }
 
-你可以用`count`函数来处理任何一个字符串，返回的值将是一个包含三个`Int`型值的元组（tuple）：
+你可以用 `count` 函数来处理任何一个字符串，返回的值将是一个包含三个 `Int` 型值的元组（tuple）：
 
     let total = count("some arbitrary string!")
     println("\(total.vowels) vowels and \(total.consonants) consonants")
     // prints "6 vowels and 13 consonants
 
 需要注意的是，元组的成员不需要在函数中返回时命名，因为它们的名字已经在函数返回类型有有了定义。
-
-## 函数参数名（Function Parameter Names）
+
+## 函数参数名称（Function Parameter Names）
 
 以上所有的函数都给它们的参数定义了`参数名（parameter name）`：
 
@@ -166,6 +172,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     }
 
 > 注意：
+>
 > 如果你提供了外部参数名，那么函数在被调用时，必须使用外部参数名。
 
 以下是个例子，这个函数使用一个`结合者（joiner）`把两个字符串联在一起：
@@ -179,29 +186,30 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     join("hello", "world", ", ")
     // returns "hello, world
 
-为了让这些字符串的用途更为明显，我们为`join`函数添加外部参数名：
+为了让这些字符串的用途更为明显，我们为 `join` 函数添加外部参数名：
 
     func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
         return s1 + joiner + s2
     }
 
-在这个版本的`join`函数中，第一个参数有一个叫`string`的外部参数名和`s1`的局部参数名，第二个参数有一个叫`toString`的外部参数名和`s2`的局部参数名，第三个参数有一个叫`withJoiner`的外部参数名和`joiner`的局部参数名。
+在这个版本的 `join` 函数中，第一个参数有一个叫 `string` 的外部参数名和 `s1` 的局部参数名，第二个参数有一个叫 `toString` 的外部参数名和 `s2` 的局部参数名，第三个参数有一个叫 `withJoiner` 的外部参数名和 `joiner` 的局部参数名。
 
 现在，你可以使用这些外部参数名以一种清晰地方式来调用函数了：
 
     join(string: "hello", toString: "world", withJoiner: ", ")
     // returns "hello, world
 
-使用外部参数名让第二个版本的`join`函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。
+使用外部参数名让第二个版本的 `join` 函数的调用更为有表现力，更为通顺，同时还保持了函数体是可读的和有明确意图的。
 
 > 注意：
+>
 > 当其他人在第一次读你的代码，函数参数的意图显得不明显时，考虑使用外部参数名。如果函数参数名的意图是很明显的，那就不需要定义外部参数名了。
 
 ### 简写外部参数名（Shorthand External Parameter Names）
 
-如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用`井号（#）`作为前缀就可以了。这告诉Swift使用这个参数名作为局部和外部参数名。
+如果你需要提供外部参数名，但是局部参数名已经定义好了，那么你不需要写两次这些参数名。相反，只写一次参数名，并用`井号（#）`作为前缀就可以了。这告诉 Swift 使用这个参数名作为局部和外部参数名。
 
-下面这个例子定义了一个叫`containsCharacter`的函数，使用`井号（#）`的方式定义了外部参数名：
+下面这个例子定义了一个叫 `containsCharacter` 的函数，使用`井号（#）`的方式定义了外部参数名：
 
     func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
         for character in string {
@@ -223,6 +231,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 你可以在函数体中为每个参数定义`默认值`。当默认值被定义后，调用这个函数时可以略去这个参数。
 
 > 注意：
+>
 > 将带有默认值的参数放在函数参数表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
 
 以下是另一个版本的`join`函数，其中`joiner`有了默认参数值：
@@ -231,12 +240,12 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         return s1 + joiner + s2
     }
 
-像第一个版本的`join`函数一样，如果`joiner`被幅值时，函数将使用这个字符串值来连接两个字符串：
+像第一个版本的 `join` 函数一样，如果 `joiner` 被赋值时，函数将使用这个字符串值来连接两个字符串：
 
     join(string: "hello", toString: "world", withJoiner: "-")
     // returns "hello-world
 
-当这个函数被调用时，如果`joiner`的值没有被指定，函数会使用默认值（" "）：
+当这个函数被调用时，如果 `joiner` 的值没有被指定，函数会使用默认值（" "）：
 
     join(string: "hello", toString:"world")
     // returns "hello world"
@@ -245,27 +254,28 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 
 在大多数情况下，给带默认值的参数起一个外部参数名是很有用的。这样可以保证当函数被调用且带默认值的参数被提供值时，实参的意图是明显的。
 
-为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了`井号（#）`一样。
+为了使定义外部参数名更加简单，当你未给带默认值的参数提供外部参数名时，Swift 会自动提供外部名字。此时外部参数名与局部名字是一样的，就像你已经在局部参数名前写了`井号（#）`一样。
 
-下面是`join`函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是`joiner`参数依然有外部参数名：
+下面是 `join` 函数的另一个版本，这个版本中并没有为它的参数提供外部参数名，但是 `joiner` 参数依然有外部参数名：
 
     func join(s1: String, s2: String, joiner: String = " ") -> String {
         return s1 + joiner + s2
     }
 
-在这个例子中，Swift自动为`joiner`提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。
+在这个例子中，Swift 自动为 `joiner` 提供了外部参数名。因此，当函数调用时，外部参数名必须使用，这样使得参数的用途变得清晰。
 
     join("hello", "world", joiner: "-")
     // returns "hello-world"
 
 > 注意：
+>
 > 你可以使用`下划线（_）`作为默认值参数的外部参数名，这样可以在调用时不用提供外部参数名。但是给带默认值的参数命名总是更加合适的。
 
 ### 可变参数（Variadic Parameters）
 
 一个`可变参数（variadic parameter）`可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入`（...）`的方式来定义可变参数。
 
-传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做`numbers`的`Double...`型可变参数，在函数体内可以当做一个叫`numbers`的`Double[]`型的数组常量。
+传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做 `numbers` 的 `Double...` 型可变参数，在函数体内可以当做一个叫 `numbers` 的 `Double[]` 型的数组常量。
 
 下面的这个函数用来计算一组任意长度数字的算术平均数：
 
@@ -282,6 +292,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     // returns 10.0, which is the arithmetic mean of these three numbers
 
 > 注意：
+>
 > 一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。
 
 如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。
@@ -292,7 +303,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 
 但是，有时候，如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数，从而避免自己在函数中定义新的变量。变量参数不是常量，你可以在函数中把它当做新的可修改副本来使用。
 
-通过在参数名前加关键字`var`来定义变量参数：
+通过在参数名前加关键字 `var` 来定义变量参数：
 
     func alignRight(var string: String, count: Int, pad: Character) -> String {
         let amountToPad = count - countElements(string)
@@ -306,27 +317,29 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     // paddedString is equal to "-----hello"
     // originalString is still equal to "hello"
 
-这个例子中定义了一个新的叫做`alignRight`的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串`"hello"`被转换成了`"-----hello"`。
+这个例子中定义了一个新的叫做 `alignRight` 的函数，用来右对齐输入的字符串到一个长的输出字符串中。左侧空余的地方用指定的填充字符填充。这个例子中，字符串`"hello"`被转换成了`"-----hello"`。
 
-`alignRight`函数将参数`string`定义为变量参数。这意味着`string`现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。
+`alignRight` 函数将参数 `string` 定义为变量参数。这意味着 `string` 现在可以作为一个局部变量，用传入的字符串值初始化，并且可以在函数体中进行操作。
 
-该函数首先计算出多少个字符需要被添加到`string`的左边，以右对齐到总的字符串中。这个值存在局部常量`amountToPad`中。这个函数然后将`amountToPad`多的填充（pad）字符填充到`string`左边，并返回结果。它使用了`string`这个变量参数来进行所有字符串操作。
+该函数首先计算出多少个字符需要被添加到 `string` 的左边，以右对齐到总的字符串中。这个值存在局部常量 `amountToPad` 中。这个函数然后将 `amountToPad` 多的填充（pad）字符填充到 `string` 左边，并返回结果。它使用了 `string` 这个变量参数来进行所有字符串操作。
 
 > 注意：
+>
 > 对变量参数所进行的修改在函数调用结束后变消息了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。
 
 ### 输入输出参数（In-Out Parameters）
 
 变量参数，正如上面所述，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
 
-定义一个输入输出参数时，在参数定义前加`inout`关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
+定义一个输入输出参数时，在参数定义前加 `inout` 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
 
 你只能传入一个变量作为输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加`&`符，表示这个值可以被函数修改。
 
 > 注意：
-> 输入输出参数不能有默认值，而且变量参数不能用`inout`标记。如果你用`inout`标记一个参数，这个参数不能别`var`或者`let`标记。
+>
+> 输入输出参数不能有默认值，而且变量参数不能用 `inout` 标记。如果你用 `inout` 标记一个参数，这个参数不能别 `var` 或者 `let` 标记。
 
-下面是例子，`swapTwoInts`函数，有两个分别叫做`a`和`b`的输出输出参数：
+下面是例子，`swapTwoInts` 函数，有两个分别叫做 `a` 和 `b` 的输出输出参数：
 
     func swapTwoInts(inout a: Int, inout b: Int) {
         let temporaryA = a
@@ -334,9 +347,9 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         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` 函数前，都加了 `&` 的前缀：
 
     var someInt = 3
     var anotherInt = 107
@@ -344,11 +357,12 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     println("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`的值。输入输出参数是函数对函数体外产生影响的另一种方式。
-
+>
+> 输出输出参数和返回值是不一样的。上面的 `swapTwoInts` 函数并没有定义任何返回值，但仍然修改了 `someInt` 和 `anotherInt` 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
+
 ## 函数类型（Function Types）
 
 每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
@@ -362,9 +376,9 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         return a * b
     }
 
-这个例子中定义了两个简单的数学函数：`addTwoInts`和`multiplyTwoInts`。这两个函数都传入两个`Int`类型， 返回一个合适的`Int`值。
+这个例子中定义了两个简单的数学函数：`addTwoInts` 和 `multiplyTwoInts`。这两个函数都传入两个 `Int` 类型， 返回一个合适的`Int`值。
 
-这两个函数的类型是`(Int, Int) -> Int`，可以读作“这个函数类型，它有两个`Int`型的参数并返回一个`Int`型的值。”。
+这两个函数的类型是 `(Int, Int) -> Int`，可以读作“这个函数类型，它有两个 `Int` 型的参数并返回一个 `Int` 型的值。”。
 
 下面是另一个例子，一个没有参数，也没有返回值的函数：
 
@@ -372,7 +386,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         println("hello, world")
     }
 
-这个函数的类型是：`() -> ()`，或者叫“没有参数，并返回`Void`类型的函数。”。没有指定返回类型的函数总返回	`Void`。在Swift中，`Void`与空的元组是一样的。
+这个函数的类型是：`() -> ()`，或者叫“没有参数，并返回 `Void` 类型的函数。”。没有指定返回类型的函数总返回 `Void`。在Swift中，`Void` 与空的元组是一样的。
 
 ### 使用函数类型（Using Function Types）
 
@@ -382,11 +396,11 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
 
 这个可以读作：
 
-“定义一个叫做`mathFunction`的变量，类型是‘一个有两个`Int`型的参数并返回一个`Int`型的值的函数’，并让这个新变量指向`addTwoInts`函数”。
+“定义一个叫做 `mathFunction` 的变量，类型是‘一个有两个 `Int` 型的参数并返回一个 `Int` 型的值的函数’，并让这个新变量指向 `addTwoInts` 函数”。
 
-`addTwoInts`和`mathFunction`有同样的类型，所以这个赋值过程在Swift类型检查中是允许的。
+`addTwoInts` 和 `mathFunction` 有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。
 
-现在，你可以用`mathFunction`来调用被赋值的函数了：
+现在，你可以用 `mathFunction` 来调用被赋值的函数了：
 
     println("Result: \(mathFunction(2, 3))")
     // prints "Result: 5
@@ -397,7 +411,7 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     println("Result: \(mathFunction(2, 3))")
     // prints "Result: 6"
 
-就像其他类型一样，当赋值一个函数给常量或变量时，你可以让Swift来推测其函数类型：
+就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推测其函数类型：
 
     let anotherMathFunction = addTwoInts
     // anotherMathFunction is inferred to be of type (Int, Int) -> Int
@@ -414,17 +428,17 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     printMathResult(addTwoInts, 3, 5)
     // 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）
 
 你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（`->`）后写一个完整的函数类型。
 
-下面的这个例子中定义了两个简单函数，分别是`stepForward`和`stepBackward`。`stepForward`函数返回一个比输入值大一的值。`stepBackward`函数返回一个比输入值小一的值。这两个函数的类型都是`(Int) -> Int`：
+下面的这个例子中定义了两个简单函数，分别是 `stepForward` 和`stepBackward`。`stepForward` 函数返回一个比输入值大一的值。`stepBackward` 函数返回一个比输入值小一的值。这两个函数的类型都是 `(Int) -> Int`：
 
     func stepForward(input: Int) -> Int {
         return input + 1
@@ -433,21 +447,21 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
         return input - 1
     }
 
-下面这个叫做`chooseStepFunction`的函数，它的返回类型是`(Int) -> Int`的函数。`chooseStepFunction`根据布尔值`backwards`来返回`stepForward`函数或`stepBackward`函数：
+下面这个叫做 `chooseStepFunction` 的函数，它的返回类型是 `(Int) -> Int` 的函数。`chooseStepFunction` 根据布尔值 `backwards` 来返回 `stepForward` 函数或 `stepBackward` 函数：
 
     func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
         return backwards ? stepBackward : stepForward
     }
 
-你现在可以用`chooseStepFunction`来获得一个函数，不管是那个方向：
+你现在可以用 `chooseStepFunction` 来获得一个函数，不管是那个方向：
 
     var currentValue = 3
     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`：
+现在，`moveNearerToZero` 指向了正确的函数，它可以被用来数到`0`：
 
     println("Counting to zero:")
     // Counting to zero:
@@ -460,14 +474,14 @@ Swift统一的函数语法足够灵活，可以用来表示任何函数，包括
     // 2...
     // 1...
     // zero!
-
+
 ## 嵌套函数（Nested Functions）
 
 这章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。
 
 默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
 
-你可以用返回嵌套函数的方式重写`chooseStepFunction`函数：
+你可以用返回嵌套函数的方式重写 `chooseStepFunction` 函数：
 
     func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
         func stepForward(input: Int) -> Int { return input + 1 }
diff --git a/source/chapter2/07_Closures.md b/source/chapter2/07_Closures.md
index 8cce8708..24559e31 100644
--- a/source/chapter2/07_Closures.md
+++ b/source/chapter2/07_Closures.md
@@ -1,23 +1,28 @@
-# 闭包
+> 翻译：wh1100717
+
+> 校对：lyuka
+
+# 闭包（Closures）
 -----------------
 
-本页内容包含：
+本页包含内容：
 
--   闭包表达式
--   尾随闭包
--   值捕获
--   闭包是引用类型
+-   [闭包表达式（Closure Expressions）](#closure_expressions)
+-   [尾随闭包（Trailing Closures）](#trailing_closures)
+-   [值捕获（Capturing Values）](#capturing_values)
+-   [闭包是引用类型（Closures Are Reference Types）](#closures_are_reference_types)
 
 闭包是自包含的函数代码块，可以在代码中被传递和使用。
-Swift 中的闭包与 C 和 Objective-C 中的`blocks` (代码块) 以及其他一些编程语言中的`lambdas` (匿名函数) 比较相似。
+Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。
 
-闭包可以**捕获**和存储其所在上下文中任意常量和变量的引用。
-这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在**捕获**过程中涉及到的所有内存操作。
+闭包可以捕获和存储其所在上下文中任意常量和变量的引用。
+这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift 会为您管理在捕获过程中涉及到的所有内存操作。
 
 > 注意：
-> 如果您不熟悉**捕获** (capturing) 这个概念也不用担心，您可以在 [捕获值](#capturing_values) 章节对其进行详细了解。
+>
+> 如果您不熟悉捕获（capturing）这个概念也不用担心，您可以在 [值捕获](#capturing_values) 章节对其进行详细了解。
 
-在`函数` (**这里需要函数章节提供相应链接进行配合**) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
+在[函数](../chapter2/06_Function.html) 章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：
 
 *	全局函数是一个有名字但不会捕获任何值的闭包
 *	嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
@@ -28,14 +33,12 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 *	利用上下文推断参数和返回值类型
 *	隐式返回单表达式闭包，即单表达式闭包可以省略`return`关键字
 *	参数名称缩写
-*	尾随 (Trailing) 闭包语法
+*	尾随（Trailing）闭包语法
 
 
-### 闭包表达式 (Closure Expressions)
+## 闭包表达式（Closure Expressions）
 
----
-
-嵌套函数 (**这里需要函数章节提供相应链接及锚点进行配合**) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
+[嵌套函数](../chapter2/06_Function.html#nested_function) 是一个在较复杂函数中方便进行命名和定义自包含代码模块的方式。
 当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在您处理一些函数并需要将另外一些函数作为该函数的参数时。
 
 闭包表达式是一种利用简洁语法构建内联闭包的方式。
@@ -44,12 +47,12 @@ Swift 的闭包表达式拥有简洁的风格，并鼓励在常见场景中进
 每一次迭代都用更简洁的方式描述了相同的功能。
 
 
-##### sort 函数 (The Sort Function)
+### sort 函数（The Sort Function）
 
 Swift 标准库提供了`sort`函数，会根据您提供的基于输出类型排序的闭包函数将已知类型数组中的值进行排序。
 一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。
 
-下面的闭包表达式示例使用`sort`函数对一个 **String** 类型的数组进行字母逆序排序，以下是初始数组值：
+下面的闭包表达式示例使用`sort`函数对一个`String`类型的数组进行字母逆序排序，以下是初始数组值：
 
 ```
 let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
@@ -60,7 +63,7 @@ let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
 *	已知类型的数组
 *	闭包函数，该闭包函数需要传入与数组类型相同的两个值，并返回一个布尔类型值来告诉`sort`函数当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面，排序闭包函数需要返回`true`，反之返回`false`。
 
-该例子对一个 **String** 类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
+该例子对一个`String`类型的数组进行排序，因此排序闭包函数类型需为`(String, String) -> Bool`。
 
 提供排序闭包函数的一种方式是撰写一个符合其类型要求的普通函数，并将其作为`sort`函数的第二个参数传入：
 
@@ -73,7 +76,7 @@ var reversed = sort(names, backwards)
 ```
 
 如果第一个字符串 (`s1`) 大于第二个字符串 (`s2`)，`backwards`函数返回`true`，表示在新的数组中`s1`应该出现在`s2`前。
-对于字符串中的字符来说，"大于" 表示 "按照字母顺序较晚出现"。
+对于字符串中的字符来说，“大于” 表示 “按照字母顺序较晚出现”。
 这意味着字母`"B"`大于字母`"A"`，字符串`"Tom"`大于字符串`"Tim"`。
 其将进行字母逆序排序，`"Barry"`将会排在`"Alex"`之后。
 
@@ -81,7 +84,7 @@ var reversed = sort(names, backwards)
 在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。
 
 
-##### 闭包表达式语法 (Closure Expression Syntax)
+### 闭包表达式语法（Closure Expression Syntax）
 
 闭包表达式语法有如下一般形式：
 
@@ -91,7 +94,7 @@ var reversed = sort(names, backwards)
 }
 ```
 
-闭包表达式语法可以使用常量、变量和`inout` (**这里也需要函数章节提供相应链接和锚点进行配合**) 类型作为参数，不提供默认值。
+闭包表达式语法可以使用常量、变量和`inout`类型作为参数，不提供默认值。
 也可以在参数列表的最后使用可变参数。
 元组也可以作为参数和返回值。
 
@@ -116,10 +119,10 @@ reversed = sort(names, { (s1: String, s2: String) -> Bool in
 reversed = sort(names, { (s1: String, s2: String) -> Bool in return s1 > s2 } )
 ```
 
-这说明`sort`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于`backwards`版本的代码)。
+这说明`sort`函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包（相比于`backwards`版本的代码）。
 
 
-##### 根据上下文推断类型 (Inferring Type From Context)
+### 根据上下文推断类型（Inferring Type From Context）
 
 因为排序闭包函数是作为`sort`函数的参数进行传入的，Swift可以推断其参数和返回值的类型。
 `sort`期望第二个参数是类型为`(String, String) -> Bool`的函数，因此实际上`String`,`String`和`Bool`类型并不需要作为闭包表达式定义中的一部分。
@@ -132,7 +135,7 @@ reversed = sort(names, { s1, s2 in return s1 > s2 } )
 实际上任何情况下，通过内联闭包表达式构造的闭包作为参数传递给函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。
 
 
-##### 单表达式闭包隐式返回 (Implicit Return From Single-Expression Clossures)
+### 单表达式闭包隐式返回（Implicit Return From Single-Expression Clossures）
 
 单行表达式闭包可以通过隐藏`return`关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
 
@@ -140,11 +143,11 @@ reversed = sort(names, { s1, s2 in return s1 > s2 } )
 reversed = sort(names, { s1, s2 in s1 > s2 } )
 ```
 
-在这个例子中，`sort`函数的第二个参数函数类型明确了闭包必须返回一个 **Bool** 类型值。
-因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回 **Bool** 类型值，因此这里没有歧义，`return`关键字可以省略。
+在这个例子中，`sort`函数的第二个参数函数类型明确了闭包必须返回一个`Bool`类型值。
+因为闭包函数体只包含了一个单一表达式 (`s1 > s2`)，该表达式返回`Bool`类型值，因此这里没有歧义，`return`关键字可以省略。
 
 
-##### 参数名称缩写 (Shorthand Argument Names)
+### 参数名称缩写（Shorthand Argument Names）
 
 Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过`$0`,`$1`,`$2`来顺序调用闭包的参数。
 
@@ -155,13 +158,13 @@ Swift 自动为内联函数提供了参数名称缩写功能，您可以直接
 reversed = sort(names, { $0 > $1 } )
 ```
 
-在这个例子中，`$0`和`$1`表示闭包中第一个和第二个 **String** 类型的参数。
+在这个例子中，`$0`和`$1`表示闭包中第一个和第二个`String`类型的参数。
 
 
-##### 运算符函数 (Operator Functions)
+### 运算符函数（Operator Functions）
 
 实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。
-Swift 的 **String** 类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个 **String** 类型的参数并返回 **Bool** 类型的值。
+Swift 的`String`类型定义了关于大于号 (`>`) 的字符串实现，其作为一个函数接受两个`String`类型的参数并返回`Bool`类型的值。
 而这正好与`sort`函数的第二个参数需要的函数类型相符合。
 因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：
 
@@ -169,27 +172,26 @@ Swift 的 **String** 类型定义了关于大于号 (`>`) 的字符串实现，
 reversed = sort(names, >)
 ```
 
-更多关于运算符表达式的内容请查看 [Operator Functions]() (**这里需要 Operator Functions 进行配合**)。
+更多关于运算符表达式的内容请查看 [运算符函数](../chapter2/23_Advanced_Operators.html#operator_functions)。
 
 
-### 尾随闭包 (Trailing Closures)
+## 尾随闭包（Trailing Closures）
 
----
 
 如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。
-尾随闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。
+尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
 
 ```
 func someFunctionThatTakesAClosure(closure: () -> ()) {
     // 函数体部分
 }
- 
+
 // 以下是不使用尾随闭包进行函数调用
- 
+
 someFunctionThatTakesAClosure({
     // 闭包主体部分
     })
- 
+
 // 以下是使用尾随闭包进行函数调用
 
 someFunctionThatTakesAClosure() {
@@ -197,8 +199,9 @@ someFunctionThatTakesAClosure() {
 }
 ```
 > 注意：
-> 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把 () 省略掉。
-NOTE
+>
+> 如果函数只需要闭包表达式一个参数，当您使用尾随闭包时，您甚至可以把`()`省略掉。
+
 
 在上例中作为`sort`函数参数的字符串排序闭包可以改写为：
 
@@ -207,13 +210,13 @@ reversed = sort(names) { $0 > $1 }
 ```
 
 当闭包非常长以至于不能在一行中进行书写时，尾随闭包变得非常有用。
-举例来说，Swift 的 **Array** 类型有一个`map`方法，其获取一个闭包表达式作为其唯一参数。
+举例来说，Swift 的`Array`类型有一个`map`方法，其获取一个闭包表达式作为其唯一参数。
 数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。
 具体的映射方式和返回值类型由闭包来指定。
 
 当提供给数组闭包函数后，`map`方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。
 
-下例介绍了如何在`map`方法中使用尾随闭包将 **Int** 类型数组`[16,58,510]`转换为包含对应 **String** 类型的数组`["OneSix", "FiveEight", "FiveOneZero"]`:
+下例介绍了如何在`map`方法中使用尾随闭包将`Int`类型数组`[16,58,510]`转换为包含对应`String`类型的数组`["OneSix", "FiveEight", "FiveOneZero"]`:
 
 ```
 let digitNames = [
@@ -246,19 +249,20 @@ let strings = numbers.map {
 `map`在数组中为每一个元素调用了闭包表达式。
 您不需要指定闭包的输入参数`number`的类型，因为可以通过要映射的数组类型进行推断。
 
-闭包`number`参数被声明为一个变量参数 (变量的具体描述请参看[Constant and Variable Parameters]()(**这里需要Closure Expression Syntax进行配合**))，因此可以在闭包函数体内对其进行修改。
-闭包表达式制定了返回类型为 **String**，以表明存储映射值的新数组类型为 **String**。
+闭包`number`参数被声明为一个变量参数（变量的具体描述请参看[常量参数和变量参数](../chapter2/06_Functions.html#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)。
+（在表达式`number % 10`中，如果number为16，则返回6，58返回8，510返回0）。
 
 `number`变量之后除以10。
 因为其是整数，在计算过程中未除尽部分被忽略。
@@ -269,9 +273,8 @@ let strings = numbers.map {
 上例中尾随闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在`map`函数的括号内。
 
 
-### 捕获值 (Capturing Values)
+## 捕获值（Capturing Values）
 
----
 
 闭包可以在其定义的上下文中捕获常量或变量。
 即使定义这些常量和变量的原域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
@@ -297,13 +300,13 @@ func makeIncrementor(forIncrement amount: Int) -> () -> Int {
 
 `makeIncrementor`返回类型为`() -> Int`。
 这意味着其返回的是一个函数，而不是一个简单类型值。
-该函数在每次调用时不接受参数只返回一个 **Int** 类型的值。
-关于函数返回其他函数的内容，请查看[Function Types as Return Types]()(**需要函数章节进行配合**)。
+该函数在每次调用时不接受参数只返回一个`Int`类型的值。
+关于函数返回其他函数的内容，请查看[函数类型作为返回类型](../chapter2/06_Functions.html#function_types_as_return_types)。
 
 `makeIncrementor`函数定义了一个整型变量`runningTotal`(初始为0) 用来存储当前跑步总数。
 该值通过`incrementor`返回。
 
-`makeIncrementor`有一个 **Int** 类型的参数，其外部命名为`forIncrement`， 内部命名为`amount`，表示每次`incrementor`被调用时`runningTotal`将要增加的量。
+`makeIncrementor`有一个`Int`类型的参数，其外部命名为`forIncrement`， 内部命名为`amount`，表示每次`incrementor`被调用时`runningTotal`将要增加的量。
 
 `incrementor`函数用来执行实际的增加操作。
 该函数简单地使`runningTotal`增加`amount`，并将其返回。
@@ -324,6 +327,7 @@ func incrementor() -> Int {
 然而，因为每次调用该函数的时候都会修改`runningTotal`的值，`incrementor`捕获了当前`runningTotal`变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当`makeIncrementor`结束时候并不会消失，也保证了当下一次执行`incrementor`函数时，`runningTotal`可以继续增加。
 
 > 注意：
+>
 > Swift 会决定捕获引用还是拷贝值。
 > 您不需要标注`amount`或者`runningTotal`来声明在嵌入的`incrementor`函数中的使用方式。
 > Swift 同时也处理`runingTotal`变量的内存管理操作，如果不再被`incrementor`函数使用，则会被清除。
@@ -358,13 +362,13 @@ incrementByTen()
 ```
 
 > 注意：
+>
 > 如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。
-> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [Strong Reference Cycles for Closures]()(**需要ARC章节进行配合**)。
+> Swift 使用捕获列表来打破这种强引用环。更多信息，请参考 [闭包引起的循环强引用](../chapter2/16_Automatic_Reference_Counting.html#strong_reference_cycles_for_closures)。
 
 
-### 闭包是引用类型
+## 闭包是引用类型（Closures Are Reference Types）
 
----
 
 上面的例子中，`incrementBySeven`和`incrementByTen`是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。
 这是因为函数和闭包都是引用类型。
diff --git a/source/chapter2/08_Enumerations.md b/source/chapter2/08_Enumerations.md
index ec177e32..ecee602e 100644
--- a/source/chapter2/08_Enumerations.md
+++ b/source/chapter2/08_Enumerations.md
@@ -1,23 +1,27 @@
+> 翻译：yankuangshi
+
+> 校对：shinyzhu
+
 # 枚举（Enumerations）
 
------------------
+---
 
 本页内容包含：
 
 -	[枚举语法（Enumeration Syntax）](#enumeration_syntax)
--	[匹配枚举值与`Switch`语句（Matching Enumeration Values with a Switch Statement）](#matching_enumeration_values_with_a_switch_statement)
--	[关联值（Associated values）](#associated_values)
--	[原始值（Raw values）](#raw_values)
+-	[匹配枚举值与`Swith`语句（Matching Enumeration Values with a Switch Statement）](#matching_enumeration_values_with_a_switch_statement)
+-	[实例值（Associated Values）](#associated_values)
+-	[原始值（Raw Values）](#raw_values)
 
-**枚举**定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
+枚举定义了一个通用类型的一组相关的值，使你可以在你的代码中以一个安全的方式来使用这些值。
 
-如果你熟悉 C 语言，你就会知道，在 C 语言中枚举指定相关名称为一组整型值。Swift 中的枚举更加灵活，不必给每一个枚举成员（enumeration member）提供一个值。如果一个值（被认为是“原始”值）被提供给每个枚举成员，则该值可以是一个字符串，一个字符，或是一个整型值或浮点值。
+如果你熟悉 C 语言，你就会知道，在 C 语言中枚举指定相关名称为一组整型值。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果一个值（被认为是“原始”值）被提供给每个枚举成员，则该值可以是一个字符串，一个字符，或是一个整型值或浮点值。
 
-此外，枚举成员可以指定任何类型的关联值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。
+此外，枚举成员可以指定任何类型的实例值存储到枚举成员值中，就像其他语言中的联合体（unions）和变体（variants）。你可以定义一组通用的相关成员作为枚举的一部分，每一组都有不同的一组与它相关的适当类型的数值。
 
-在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多传统上只被类所支持的特征，例如计算型属性（computed properties)，用于提供关于枚举当前值的附加信息，实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造器（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
+在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多传统上只被类（class)所支持的特征，例如计算型属性（computed properties)，用于提供关于枚举当前值的附加信息， 实例方法（instance methods），用于提供和枚举所代表的值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始成员值；可以在原始的实现基础上扩展它们的功能；可以遵守协议（protocols）来提供标准的功能。
 
-欲了解更多相关功能，请参考[属性](../chapter2/10_Properties.html)，[方法](../chapter2/11_Methodes.html)，[构造过程](../chapter2/14_Initialization.html)，[扩展](../chapter2/20_Extensions.html)，和[协议](../chapter2/21_Protocols.html)。
+欲了解更多相关功能，请参见[属性（Properties）](10_Properties.html)，[方法（Methods）](11_Methods.html)，[构造过程（Initialization）](14_Initialization.html)，[扩展（Extensions）](20_Extensions.html)和[协议（Protocols）](21_Protocols.html)。
 
 
 ## 枚举语法
@@ -28,7 +32,6 @@
 		// enumeration definition goes here
 	}
 
-
 以下是指南针四个方向的一个例子：
 
 	enum CompassPoint {
@@ -41,7 +44,8 @@
 一个枚举中被定义的值（例如 `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`的一种显示定义中拥有各自不同的值。
 
 多个成员值可以出现在同一行上，用逗号隔开：
 
@@ -59,7 +63,6 @@
 
 `directionToHead`的类型已知时，当设定它的值时，你可以不再写类型名。使用显示类型的枚举值可以让代码具有更好的可读性。
 
-
 
 ## 匹配枚举值和`Switch`语句
 
@@ -76,7 +79,7 @@
 	case .West:
     	println("Where the skies are blue")
 	}
-	// prints "Watch out for penguins”
+	// 输出 "Watch out for penguins”
 
 你可以如此理解这段代码：
 
@@ -84,7 +87,7 @@
 
 等等依次类推。
 
-正如在[控制流](../chapter2/05_Control_Flow.html)中介绍，当考虑一个枚举的成员们时，一个`switch`语句必须全面。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。全面性的要求确保了枚举成员不会被意外遗漏。
+正如在[控制流（Control Flow）](05_Control_Flow.html)中介绍，当考虑一个枚举的成员们时，一个`switch`语句必须全面。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。全面性的要求确保了枚举成员不会被意外遗漏。
 
 当不需要匹配每个枚举成员的时候，你可以提供一个默认`default`分支来涵盖所有未明确被提出的任何成员：
 
@@ -95,20 +98,20 @@
 	default:
     	println("Not a safe place for humans")
 	}
-	// prints "Mostly harmless”
+	// 输出 "Mostly harmless”
 
 
-## 关联值（Associated Values）
+## 实例值（Associated Values）
 
-上一小节的例子演示了一个枚举的成员是如何被定义（分类）的。你可以为`Planet.Earth`设置一个常量或则变量，并且在之后查看这个值。然而，有时候会很有用如果能够把其他类型的关联值和成员值一起存储起来。这能让你随着成员值存储额外的自定义信息，并且当每次你在代码中利用该成员时允许这个信息产生变化。
+上一小节的例子演示了一个枚举的成员是如何被定义（分类）的。你可以为`Planet.Earth`设置一个常量或则变量，并且在之后查看这个值。然而，有时候会很有用如果能够把其他类型的实例值和成员值一起存储起来。这能让你随着成员值存储额外的自定义信息，并且当每次你在代码中利用该成员时允许这个信息产生变化。
 
-你可以定义 Swift 的枚举存储任何类型的关联值，如果需要的话，每个成员的数据类型可以是各不相同的。枚举的这种特性跟其他语言中的可辨识联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。
+你可以定义 Swift 的枚举存储任何类型的实例值，如果需要的话，每个成员的数据类型可以是各不相同的。枚举的这种特性跟其他语言中的可辨识联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。
 
-例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维码，它使用数字0到9.每一个条形码都有一个代表“数字系统”的数字，该数字后接10个代表“标识符”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：
+例如，假设一个库存跟踪系统需要利用两种不同类型的条形码来跟踪商品。有些商品上标有 UPC-A 格式的一维码，它使用数字 0 到 9。每一个条形码都有一个代表“数字系统”的数字，该数字后接 10 个代表“标识符”的数字。最后一个数字是“检查”位，用来验证代码是否被正确扫描：
 
-
+
 
-其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO8859-1 字符，并且可以编码一个最多拥有2,953字符的字符串:
+其他商品上标有 QR 码格式的二维码，它可以使用任何 ISO8859-1 字符，并且可以编码一个最多拥有 2,953 字符的字符串:
 
 
 
@@ -123,23 +126,23 @@
 
 以上代码可以这么理解：
 
-“定义一个名为`Barcode`的枚举类型，它可以是`UPCA`的一个关联值（`Int`，`Int`，`Int`），或者`QRCode`的一个字符串类型（`String`）关联值。”
+“定义一个名为`Barcode`的枚举类型，它可以是`UPCA`的一个实例值（`Int`，`Int`，`Int`），或者`QRCode`的一个字符串类型（`String`）实例值。”
 
-这个定义不提供任何`Int`或`String`的实际值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，关联值的类型。
+这个定义不提供任何`Int`或`String`的实际值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，实例值的类型。
 
 然后可以使用任何一种条码类型创建新的条码，如：
 
 	var productBarcode = Barcode.UPCA(8, 85909_51226, 3)
 
-以上例子创建了一个名为`productBarcode`的新变量，并且赋给它一个`Barcode.UPCA`的关联元组值`(8, 8590951226, 3)`。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。
+以上例子创建了一个名为`productBarcode`的新变量，并且赋给它一个`Barcode.UPCA`的实例元组值`(8, 8590951226, 3)`。提供的“标识符”值在整数字中有一个下划线，使其便于阅读条形码。
 
 同一个商品可以被分配给一个不同类型的条形码，如：
 
 	productBarcode = .QRCode("ABCDEFGHIJKLMNOP")
 
-这时，原始的`Barcode.UPCA`和其整数值被新的`Barcode.QRCode`和其字符串值所替代。条形码的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它的关联值），但是在任何指定时间只能存储其中之一。
+这时，原始的`Barcode.UPCA`和其整数值被新的`Barcode.QRCode`和其字符串值所替代。条形码的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它的实例值），但是在任何指定时间只能存储其中之一。
 
-像以前那样，不同的条形码类型可以使用一个`switch`语句来检查，然而这次关联值可以被提取作为`switch`语句的一部分。你可以在`switch`的case分支代码中提取每个关联值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
+像以前那样，不同的条形码类型可以使用一个 switch 语句来检查，然而这次实例值可以被提取作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个实例值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
 
 	switch productBarcode {
 	case .UPCA(let numberSystem, let identifier, let check):
@@ -147,9 +150,9 @@
 	case .QRCode(let productCode):
     	println("QR code with value of \(productCode).")
 	}
-	// prints "QR code with value of ABCDEFGHIJKLMNOP.”
+	// 输出 "QR code with value of ABCDEFGHIJKLMNOP.”
 
-如果一个枚举成员的所有关联值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个`var`或者`let`标注在成员名称前：
+如果一个枚举成员的所有实例值被提取为常量，或者它们全部被提取为变量，为了简洁，你可以只放置一个`var`或者`let`标注在成员名称前：
 
 	switch productBarcode {
 	case let .UPCA(numberSystem, identifier, check):
@@ -157,12 +160,12 @@
 	case let .QRCode(productCode):
     	println("QR code with value of \(productCode).")
 	}
-	// prints "QR code with value of ABCDEFGHIJKLMNOP."
+	// 输出 "QR code with value of ABCDEFGHIJKLMNOP."
 
 
 ## 原始值（Raw Values）
 
-在关联值小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的关联值。作为关联值的替代，枚举成员可以被默认值（称为原始值）预先填充，其中这些原始值具有相同的类型。
+在实例值小节的条形码例子中演示了一个枚举的成员如何声明它们存储不同类型的实例值。作为实例值的替代，枚举成员可以被默认值（称为原始值）预先填充，其中这些原始值具有相同的类型。
 
 这里是一个枚举成员存储原始 ASCII 值的例子：
 
@@ -172,9 +175,9 @@
     	case CarriageReturn = "\r"
 	}
 
-在这里，称为`ASCIIControlCharacter`的枚举的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见[字符串和字符](../chapter2/03_Strings_and_Characters.html)章节。
+在这里，称为`ASCIIControlCharacter`的枚举的原始值类型被定义为字符型`Character`，并被设置了一些比较常见的 ASCII 控制字符。字符值的描述请详见字符串和字符`Strings and Characters`部分。
 
-注意，原始值和关联值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。关联值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
+注意，原始值和实例值是不相同的。当你开始在你的代码中定义枚举的时候原始值是被预先填充的值，像上述三个 ASCII 码。对于一个特定的枚举成员，它的原始值始终是相同的。实例值是当你在创建一个基于枚举成员的新常量或变量时才会被设置，并且每次当你这么做得时候，它的值可以是不同的。
 
 原始值可以是字符串，字符，或者任何整型值或浮点型值。每个原始值在它的枚举声明中必须是唯一的。当整型值被用于原始值，如果其他枚举成员没有值时，它们会自动递增。
 
@@ -211,6 +214,6 @@
 	} else {
     	println("There isn't a planet at position \(positionToFind)")
 	}
-	// prints "There isn't a planet at position 9
+	// 输出 "There isn't a planet at position 9
 
 这个范例使用可选绑定（optional binding），通过原始值`9`试图访问一个行星。`if let somePlanet = Planet.fromRaw(9)`语句获得一个可选`Planet`，如果可选`Planet`可以被获得，把`somePlanet`设置成该可选`Planet`的内容。在这个范例中，无法检索到位置为`9`的行星，所以`else`分支被执行。
diff --git a/source/chapter2/09_Classes_and_Structures.md b/source/chapter2/09_Classes_and_Structures.md
index e2fe8d83..753edbfc 100644
--- a/source/chapter2/09_Classes_and_Structures.md
+++ b/source/chapter2/09_Classes_and_Structures.md
@@ -1,20 +1,27 @@
-### 类和结构体
+> 翻译：JaySurplus
+
+> 校对：sg552
+
+# 类和结构体
 
 本页包含内容：
 
--   类和结构体对比
--   结构体和枚举是值类型
--   类是引用类型
--   类和结构体的选择
--   集合（collection）类型的赋值与复制行为
+-   [类和结构体对比](#comparing_classes_and_structures)
+-   [结构体和枚举是值类型](#structures_and_enumerations_are_value_types)
+-   [类是引用类型](#classes_are_reference_types)
+-   [类和结构体的选择](#choosing_between_classes_and_structures)
+-   [集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types)
 
 类和结构体是人们构建代码所用的一种通用且灵活的构造体。为了在类和结构体中实现各种功能，我们必须要严格按照对于常量，变量以及函数所规定的语法规则来定义属性和添加方法。
 
 与其他编程语言所不同的是，Swift 并不要求你为自定义类和结构去创建独立的接口和实现文件。你所要做的是在一个单一文件中定义一个类或者结构体，系统将会自动生成面向其它代码的外部接口。
 
-> 通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
+>  注意：
+>
+通常一个`类`的实例被称为`对象`。然而在Swift 中，类和结构体的关系要比在其他语言中更加的密切，本章中所讨论的大部分功能都可以用在类和结构体上。因此，我们会主要使用`实例`而不是`对象`。
 
-### 类和结构体对比
+
+###类和结构体对比
 Swift 中类和结构体有很多共同点。共同处在于：
 
 * 	定义属性用于储存值
@@ -24,7 +31,7 @@ Swift 中类和结构体有很多共同点。共同处在于：
 * 	通过扩展以增加默认实现的功能
 * 	符合协议以对某类提供标准功能
 
-更多信息请参见 [属性](http://)，[方法](http://)，[下标](http://)，[初始化](http://)，[扩展](http://)，和[协议](http://)。
+更多信息请参见 [属性](10_Properties.html)，[方法](11_Methods.html)，[下标](12_Subscripts.html)，[初始过程](14_Initialization.html)，[扩展](20_Extensions.html)，和[协议](21_Protocols.html)。
 
 与结构体相比，类还有如下的附加功能：
 
@@ -36,7 +43,9 @@ Swift 中类和结构体有很多共同点。共同处在于：
 
 更多信息请参见[继承](http://)，[类型转换](http://)，[初始化](http://)，和[自动引用计数](http://)。
 
->结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
+> 注意：
+>
+结构体总是通过被复制的方式在代码中传递，因此请不要使用引用计数。
 
 ### 定义
 类和结构体有着类似的定义方式。我们通过关键字`class`和`struct`来分别表示类和结构体，并在一对大括号中定义它们的具体内容：
@@ -47,8 +56,10 @@ Swift 中类和结构体有很多共同点。共同处在于：
 	struct SomeStructure {
 		// structure definition goes here
 	}
-	
-> 在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。
+
+>  注意：
+>
+在你每次定义一个新类或者结构体的时候，实际上你是有效地定义了一个新的 Swift 类型。因此请使用 `UpperCamelCase` 这种方式来命名（如 `SomeClass` 和`SomeStructure`等），以便符合标准Swift 类型的大写命名风格（如`String`，`Int`和`Bool`）。相反的，请使用`lowerCamelCase`这种方式为属性和方法命名（如`framerate`和`incrementCount`），以便和类区分。
 
 以下是定义结构体和定义类的示例：
 
@@ -74,70 +85,73 @@ Swift 中类和结构体有很多共同点。共同处在于：
 
 	let someResolution = Resolution()
 	let someVideoMode = VideoMode()
-	
-结构体和类都使用初始化器语法来生成新的实例。初始化器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。[Initialization](http://)章节会对类和结构体的初始化进行更详细的讨论。
+
+结构体和类都使用初始化器语法来生成新的实例。初始化器语法的最简单形式是在结构体或者类的类型名称后跟随一个空括弧，如`Resolution()`或`VideoMode()`。通过这种方式所创建的类或者结构体实例，其属均会被初始化为默认值。[构造过程](14_Initialization.html)章节会对类和结构体的初始化进行更详细的讨论。
 
 
 ### 属性访问
 通过使用*点语法*（*dot syntax*）,你可以访问实例中所含有的属性。其语法规则是，实例名后面紧跟属性名，两者通过点号(.)连接：
-	
+
 	println("The width of someResolution is \(someResolution.width)")
-	// prints "The width of someResolution is 0"
-	
+	// 输出 "The width of someResolution is 0"
+
 在上面的例子中，`someResolution.width`引用`someResolution`的`width`属性，返回`width`的初始值`0`。
 
 你也可以访问子属性，如何`VideoMode`中`Resolution`属性的`width`属性：
-	
+
 	println("The width of someVideoMode is \(someVideoMode.resolution.width)")
-	// prints "The width of someVideoMode is 0"
-	
+	// 输出 "The width of someVideoMode is 0"
+
 你也可以使用点语法为属性变量赋值：
-	
+
 	someVideoMode.resolution.width = 12880
 	println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
-	// prints "The width of someVideoMode is now 1280"
-	
-> 与Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要从新设置`resolution`属性。
+	// 输出 "The width of someVideoMode is now 1280"
+
+>  注意：
+>
+与 Objective-C 语言不同的是，Swift 允许直接设置结构体属性的子属性。上面的最后一个例子，就是直接设置了`someVideoMode`中`resolution`属性的`width`这个子属性，以上操作并不需要从新设置`resolution`属性。
 
 ### 结构体类型的成员逐一初始化器
 //Memberwise Initializers for structure Types
 
 所有结构体都有一个自动生成的成员逐一初始化器，用于初始化新结构体实例中成员的属性。新实例中各个属性的初始值可以通过属性的名称传递到成员逐一初始化器之中：
-	
-	let vga = resolution（width:640, heigth: 480）
-	
-与结构体不同，类实例没有默认的成员逐一初始化器。[Initialization](http://)章节会对初始化器进行更详细的讨论。
 
-### 结构体和枚举是值类型
+	let vga = resolution（width:640, heigth: 480）
+
+与结构体不同，类实例没有默认的成员逐一初始化器。[构造过程](14_Initialization.html)章节会对初始化器进行更详细的讨论。
+
+
+## 结构体和枚举是值类型
 
 值类型被赋予给一个变量，常数或者本身被传递给一个函数的时候，实际上操作的是其的拷贝。
 
-在之前的章节中，我们已经大量使用了值类型。实际上，在Swift 中，所有的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)，都是值类型，并且都是以结构体的形式在后台所实现。
+在之前的章节中，我们已经大量使用了值类型。实际上，在 Swift 中，所有的基本类型：整数(Integer)、浮点数(floating-point)、布尔值(Booleans)、字符串(string)、数组(array)和字典(dictionaries)，都是值类型，并且都是以结构体的形式在后台所实现。
 
-在Swift中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
+在 Swift 中，所有的结构体和枚举都是值类型。这意味着它们的实例，以及实例中所包含的任何值类型属性，在代码中传递的时候都会被复制。
 
 请看下面这个示例，其使用了前一个示例中`Resolution`结构体：
-	
+
 	let hd = Resolution(width: 1920, height: 1080)
 	var cinema = hd
-	
-在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率(1920像素宽，1080像素高)的`Resolution`实例。
+
+在以上示例中，声明了一个名为`hd`的常量，其值为一个初始化为全高清视频分辨率(1920 像素宽，1080 像素高)的`Resolution`实例。
 
 然后示例中又声明了一个名为`cinema`的变量，其值为之前声明的`hd`。因为`Resolution`是一个结构体，所以`cinema`的值其实是`hd`的一个拷贝副本，而不是`hd`本身。尽管`hd`和`cinema`有着相同的宽(width)和高(height)属性，但是在后台中，它们是两个完全不同的实例。
 
-下面，为了符合数码影院放映的需求(2048像素宽，1080像素高)，`cinema`的`width`属性需要作如下修改：
-	
+下面，为了符合数码影院放映的需求(2048 像素宽，1080 像素高)，`cinema`的`width`属性需要作如下修改：
+
 	cinema.width = 2048
 
 这里，将会显示`cinema`的`width`属性确已改为了`2048`：
-	
+
 	println("cinema is now  \(cinema.width) pixels wide")
-	// prints "cinema is now 2048 pixels wide"
+	// 输出 "cinema is now 2048 pixels wide"
 
 然而，初始的`hd`实例中`width`属性还是`1920`：
-	
+
 	println("hd is still \(hd.width	) pixels wide")
-	// prints "hd is still 1920 pixels wide"
+	// 输出 "hd is still 1920 pixels wide"
 
 在将`hd`赋予给`cinema`的时候，实际上是将`hd`中所储存的`值(values)`进行拷贝，然后将拷贝的数据储存到新的`cinema`实例中。结果就是两个完全独立的实例碰巧包含有相同的数值。由于两者相互独立，因此将`cinema`的`width`修改为`2048`并不会影响`hd`中的宽(width)。
 
@@ -152,15 +166,16 @@ Swift 中类和结构体有很多共同点。共同处在于：
 	if rememberDirection == .West {
 		println("The remembered direction is still .West")
 	}
-	// prints "The remembered direction is still .West"
+	// 输出 "The remembered direction is still .West"
 
 上例中`rememberedDirection`被赋予了`currentDirection`的值(value)，实际上它被赋予的是值(value)的一个拷贝。赋值过程结束后再修改`currentDirection`的值并不影响`rememberedDirection`所储存的原始值(value)的拷贝。
 
-### 类是引用类型
+
+## 类是引用类型
 与值类型不同，引用类型在被赋予到一个变量，常量或者被传递到一个函数时，操作的并不是其拷贝。因此，引用的是已存在的实例本身而不是其拷贝。
 
 请看下面这个示例，其使用了之前定义的`VideoMode`类：
-	
+
 	let tenEighty = VideoMode()
 	tenEighty.resolution = hd
 	tenEighty.interlaced = true
@@ -170,16 +185,16 @@ Swift 中类和结构体有很多共同点。共同处在于：
 以上示例中，声明了一个名为`tenEighty`的常量，其引用了一个`VideoMode`类的新实例。在之前的示例中，这个视频模式(video mode)被赋予了HD分辨率(1920*1080)的一个拷贝(`hd`)。同时设置为交错(interlaced),命名为`“1080i”`。最后，其帧率是`25.0`帧每秒。
 
 然后，`tenEighty` 被赋予名为`alsoTenEighty`的新常量，同时对`alsoTenEighty`的帧率进行修改：
-	
+
 	let alsoTenEighty = tenEighty
 	alsoTenEighty.frameRate = 30.0
 
 因为类是引用类型，所以`tenEight`和`alsoTenEight`实际上引用的是相同的`VideoMode`实例。换句话说，它们只是同一个实例的两种叫法。
 
 下面，通过查看`tenEighty`的`frameRate`属性，我们会发现它正确的显示了基本`VideoMode`实例的新帧率，其值为`30.0`：
-	
+
 	println("The frameRate property of tenEighty is now \(tenEighty.frameRate)")
-	// prints "The frameRate property of theEighty is now 30.0"
+	// 输出 "The frameRate property of theEighty is now 30.0"
 
 需要注意的是`tenEighty`和`alsoTenEighty`被声明为*常量(constants)*而不是变量。然而你依然可以改变`tenEighty.frameRate`和`alsoTenEighty.frameRate`,因为这两个常量本身不会改变。它们并不`储存`这个`VideoMode`实例，在后台仅仅是对`VideoMode`实例的引用。所以，改变的是被引用的基础`VideoMode`的`frameRate`参数，而不改变常量的值。
 
@@ -188,28 +203,29 @@ Swift 中类和结构体有很多共同点。共同处在于：
 因为类是引用类型，有可能有多个常量和变量在后台同时引用某一个类实例。(对于结构体和枚举来说，这并不成立。因为它们作值类型，在被赋予到常量，变量或者传递到函数时，总是会被拷贝。)
 
 如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的，Swift 内建了两个恒等运算符：
-	
+
 * 等价于 ( === )
 * 不等价于 ( !== )
 
 以下是运用这两个运算符检测两个常量或者变量是否引用同一个实例：
-	
+
 	if tenEighty === alsoTenTighty {
 		println("tenTighty and alsoTenEighty refer to the same Resolution instance.")
 	}
-	//prints "tenEighty and alsoTenEighty refer to the same Resolution instance."
-	
+	//输出 "tenEighty and alsoTenEighty refer to the same Resolution instance."
+
 请注意“等价于”(用三个等号表示，===) 与“等于”(用两个等号表示，==)的不同：
-	
+
 * “等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。
 * “等于”表示两个实例的值“相等”或“相同”，判定时要遵照类设计者定义定义的评判标准，因此相比于“相等”，这是一种更加合适的叫法。
 
-当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[Equivalence Operators](http://)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
+当你在定义你的自定义类和结构体的时候，你有义务来决定判定两个实例“相等”的标准。在章节[运算符函数(Operator Functions)](23_Advanced_Operators.html#operator_functions)中将会详细介绍实现自定义“等于”和“不等于”运算符的流程。
 
 ### 指针
-如果你有C，C++或者Objective-C语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
+如果你有 C，C++ 或者 Objective-C 语言的经验，那么你也许会知道这些语言使用指针来引用内存中的地址。一个 Swift 常量或者变量引用一个引用类型的实例与C语言中的指针类似，不同的是并不直接指向内存中的某个地址，而且也不要求你使用星号(*)来表明你在创建一个引用。Swift 中这些引用与其它的常量或变量的定义方式相同。
 
-### 类和结构体的选择
+
+## 类和结构体的选择
 在你的代码中，你可以使用类和结构体来定义你的自定义数据类型。
 
 然而，结构体实例总是通过值传递，类实例总是通过引用传递。这意味两者适用不同的任务。当你的在考虑一个工程项目的数据构造和功能的时候，你需要决定每个数据构造是定义成类还是结构体。
@@ -229,31 +245,34 @@ Swift 中类和结构体有很多共同点。共同处在于：
 
 在所有其它案例中，定义一个类，生成一个它的实例，并通过引用来管理和传递。实际中，这意味着绝大部分的自定义数据构造都应该是类，而非结构体。
 
-### 集合(Collection)类型的赋值和拷贝行为
+
+## 集合(Collection)类型的赋值和拷贝行为
 Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实现。然而当数组被赋予一个常量或变量，或被传递给一个函数或方法时，其拷贝行为与字典和其它结构体有些许不同。
 
 以下对`数组`和`结构体`的行为描述与对`NSArray`和`NSDictionary`的行为描述在本质上不同，后者是以类的形式实现，前者是以结构体的形式实现。`NSArray`和`NSDictionary`实例总是以对已有实例引用,而不是拷贝的方式被赋值和传递。
 
->以下是对于数组，字典，字符串和其它值的`拷贝`的描述。 
+> 注意：
+>
+以下是对于数组，字典，字符串和其它值的`拷贝`的描述。
 在你的代码中，拷贝好像是确实是在有拷贝行为的地方产生过。然而，在Swift 的后台中，只有确有必要，`实际(actual)`拷贝才会被执行。Swift 管理所有的值拷贝以确保性能最优化的性能，所以你也没有必要去避免赋值以保证最优性能。(实际赋值由系统管理优化)
 
 ### 字典类型的赋值和拷贝行为
-无论何时将一个`字典`实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节[Structures and Enumerations Are Value Types](http://)中将会对此过程进行详细介绍。
+无论何时将一个`字典`实例赋给一个常量或变量，或者传递给一个函数或方法，这个字典会即会在赋值或调用发生时被拷贝。在章节[结构体和枚举是值类型](#structures_and_enumerations_are_value_types)中将会对此过程进行详细介绍。
 
 如果`字典`实例中所储存的键(keys)和/或值(values)是值类型(结构体或枚举)，当赋值或调用发生时，它们都会被拷贝。相反，如果键(keys)和/或值(values)是引用类型，被拷贝的将会是引用，而不是被它们引用的类实例或函数。`字典`的键和值的拷贝行为与结构体所储存的属性的拷贝行为相同。
 
 下面的示例定义了一个名为`ages`的字典，其中储存了四个人的名字和年龄。`ages`字典被赋予了一个名为`copiedAges`的新变量，同时`ages`在赋值的过程中被拷贝。赋值结束后，`ages`和`copiedAges`成为两个相互独立的字典。
-	
+
 	var ages = ["Peter": 23, "Wei": 35, "Anish": 65, "Katya": 19]
 	var copiedAges = ages
 
 这个字典的键(keys)是`字符串(String)`类型，值(values)是`整(Int)`类型。这两种类型在Swift 中都是值类型(value types)，所以当字典被拷贝时，两者都会被拷贝。
 
 我们可以通过改变一个字典中的年龄值(age value)，检查另一个字典中所对应的值，来证明`ages`字典确实是被拷贝了。如果在`copiedAges`字典中将`Peter`的值设为`24`，那么`ages`字典仍然会返回修改前的值`23`：
-	
+
 	copiedAges["Peter"] = 24
 	println(ages["Peter"])
-	// prints "23"
+	// 输出 "23"
 
 ### 数组的赋值和拷贝行为
 
@@ -261,10 +280,10 @@ Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实
 
 如果你将一个`数组(Array)`实例赋给一个变量或常量，或者将其作为参数传递给函数或方法调用，在事件发生时数组的内容`不`会被拷贝。相反，数组公用相同的元素序列。当你在一个数组内修改某一元素，修改结果也会在另一数组显示。
 
-对数组来说，拷贝行为仅仅当操作有可能修改数组`长度`时才会发生。这种行为包括了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[Assignment and Copy Behavior for Dictionaries](http://)。
+对数组来说，拷贝行为仅仅当操作有可能修改数组`长度`时才会发生。这种行为包括了附加(appending),插入(inserting),删除(removing)或者使用范围下标(ranged subscript)去替换这一范围内的元素。只有当数组拷贝确要发生时，数组内容的行为规则与字典中键值的相同，参见章节[集合（collection）类型的赋值与复制行为](#assignment_and_copy_behavior_for_collection_types。
 
 下面的示例将一个`整数(Int)`数组赋给了一个名为`a`的变量，继而又被赋给了变量`b`和`c`：
-	
+
 	var a = [1, 2, 3]
 	var b = a
 	var c = a
@@ -277,9 +296,9 @@ Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实
 	// 1
 	println(c[0])
 	// 1
-	
+
 如果通过下标语法修改数组中某一元素的值，那么`a`,`b`,`c`中的相应值都会发生改变。请注意当你用下标语法修改某一值时，并没有拷贝行为伴随发生，因为下表语法修改值时没有改变数组长度的可能：
-	
+
 	a[0] = 42
 	println(a[0])
 	// 42
@@ -287,12 +306,12 @@ Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实
 	// 42
 	println(c[0])
 	// 42
-	
+
 然而，当你给`a`附加新元素时，数组的长度`会`改变。
-当附加元素这一事件发生时，Swift 语言会创建这个数组的一个拷贝。从此以后，`a`将会是原数组的一个独立拷贝。
+当附加元素这一事件发生时，Swift 会创建这个数组的一个拷贝。从此以后，`a`将会是原数组的一个独立拷贝。
 
 拷贝发生后，如果再修改`a`中元素值的话，`a`将会返回与`b`，`c`不同的结果，因为后两者引用的是原来的数组：
-	
+
 	a.append(4)
 	a[0] = 777
 	println(a[0])
@@ -301,18 +320,18 @@ Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实
 	// 42
 	println(c[0])
 	// 42
-	
+
 ### 确保数组的唯一性
 在操作一个数组，或将其传递给函数以及方法调用之前是很有必要先确定这个数组是有一个唯一拷贝的。通过在数组变量上调用`unshare`方法来确定数组引用的唯一性。(当数组赋给常量时，不能调用`unshare`方法)
-	
+
 如果一个数组被多个变量引用，在其中的一个变量上调用`unshare`方法，则会拷贝此数组，此时这个变量将会有属于它自己的独立数组拷贝。当数组仅被一个变量引用时，则不会有拷贝发生。
 
 在上一个示例的最后，`b`和`c`都引用了同一个数组。此时在`b`上调用`unshare`方法则会将`b`变成一个唯一个拷贝：
-	
+
 	b.unshare()
-	
+
 在`unshare`方法调用后再修改`b`中第一个元素的值，这三个数组(`a`,`b`,`c`)会返回不同的三个值：
-	
+
 	b[0] = -105
 	println(a[0])
 	// 77
@@ -320,44 +339,46 @@ Swift 中`数组(Array)`和`字典(Dictionary)`类型均以结构体的形式实
 	// -105
 	println(c[0])
 	// 42
-	
+
 
 ### 判定两个数组是否共用相同元素
 
 我们通过使用恒等运算符(identity operators)( === and !==)来判定两个数组或子数组共用相同的储存空间或元素。
 
 下面这个示例使用了“恒等于(identical to)” 运算符(===) 来判定`b`和`c`是否共用相同的数组元素：
-	
+
 	if b === c {
 		println("b and c still share the same array elements.")
 	} else {
 		println("b and c now refer to two independent sets of array elements.")
 	}
-	
-	// prints "b and c now refer totwo independent sets of array elements."
-	
+
+	// 输出 "b and c now refer totwo independent sets of array elements."
+
 此外，我们还可以使用恒等运算符来判定两个子数组是否共用相同的元素。下面这个示例中，比较了`b`的两个相等的子数组，并且确定了这两个子数组都引用相同的元素：
-	
+
 	if b[0...1] === b[0...1] {
 		println("These two subarrays share the same elements.")
 	} else {
 		println("These two subarrays do not share the same elements.")
 	}
-	// prints "These two subarrays share the same elements."
-	
+	// 输出 "These two subarrays share the same elements."
+
 ### 强制复制数组
 
 我们通过调用数组的`copy`方法进行强制显性复制。这个方法对数组进行了浅拷贝(shallow copy),并且返回一个包含此拷贝的新数组。
 
 下面这个示例中定义了一个`names`数组，其包含了七个人名。还定义了一个`copiedNames`变量，用以储存在`names`上调用`copy`方法所返回的结果：
-	
+
 	var names = ["Mohsen", "Hilary", "Justyn", "Amy", "Rich", "Graham", "Vic"]
 	var copiedNames = names.copy
-	
+
 我们可以通过修改一个数组中某元素，并且检查另一个数组中对应元素的方法来判定`names`数组确已被复制。如果你将`copiedNames`中第一个元素从"`Mohsen`"修改为"`Mo`",则`names`数组返回的仍是拷贝发生前的"`Mohsen`"：
-	
+
 	copiedName[0] = "Mo"
 	println(name[0])
-	// prints "Mohsen"
+	// 输出 "Mohsen"
 
-> 如果你仅需要确保你对数组的引用是唯一引用，请调用`unshare`方法，而不是`copy`方法。`unshare`方法仅会在确有必要时才会创建数组拷贝。`copy`方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。
+> 注意：
+>
+如果你仅需要确保你对数组的引用是唯一引用，请调用`unshare`方法，而不是`copy`方法。`unshare`方法仅会在确有必要时才会创建数组拷贝。`copy`方法会在任何时候都创建一个新的拷贝，即使引用已经是唯一引用。
diff --git a/source/chapter2/10_Properties.md b/source/chapter2/10_Properties.md
index 466c2f29..394bf800 100644
--- a/source/chapter2/10_Properties.md
+++ b/source/chapter2/10_Properties.md
@@ -1,3 +1,7 @@
+> 翻译：shinyzhu
+
+> 校对：pp-prog
+
 # 属性 (Properties)
 
 ---
@@ -8,22 +12,22 @@
 - [计算属性（Computed Properties）](#computed_properties)
 - [属性监视器（Property Observers）](#property_observers)
 - [全局变量和局部变量（Global and Local Variables）](global_and_local_variables)
-- [类属性（Type Properties）](#type_properties)
+- [类型属性（Type Properties）](#type_properties)
 
-**属性**将值跟特定的类、结构或枚举关联。一种是存储属性，把常量或变量的值作为实例的一部分，一种是计算属性，它计算一个值。计算属性可以用于类、结构和枚举里，存储属性只能用于类和结构。
+**属性**将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分，计算属性计算（而不是存储）一个值。计算属性可以用于类、结构体和枚举里，存储属性只能用于类和结构体。
 
-存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类属性。
+存储属性和计算属性通常用于特定类型的实例，但是，属性也可以直接用于类型本身，这种属性称为类型属性。
 
 另外，还可以定义属性监视器来监控属性值的变化，以此来触发一个自定义的操作。属性监视器可以添加到自己写的存储属性上，也可以添加到从父类继承的属性上。
 
 
 ## 存储属性
 
-简单来说，一个存储属性就是一个特定类型实例里表示常量或变量的部分，存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
+简单来说，一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量，存储属性可以是*变量存储属性*（用关键字`var`定义），也可以是*常量存储属性*（用关键字`let`定义）。
 
-可以在定义存储属性的时候指定默认值，详见[默认属性值](chapter2/14_Initialization.html#default_property_values)一节。也可以在初始化阶段设置或修改存储属性的值，甚至修改常量存储属性的值，详见[在初始化阶段修改常量存储属性](chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。
+可以在定义存储属性的时候指定默认值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[默认属性值](../chapter2/14_Initialization.html#default_property_values)一节。也可以在构造过程中设置或修改存储属性的值，甚至修改常量存储属性的值，请参考[构造过程](../chapter2/14_Initialization.html)一章的[在初始化阶段修改常量存储属性](../chapter2/14_Initialization.html#modifying_constant_properties_during_initialization)一节。
 
-下面的例子定义了一个名为`FixedLengthRange`的结构体，表示一个在创建后无法修改整数范围的类型：
+下面的例子定义了一个名为`FixedLengthRange`的结构体，他描述了一个在创建后无法修改值域宽度的区间：
 
 ```
 struct FixedLengthRange {
@@ -31,13 +35,13 @@ struct FixedLengthRange {
     let length: Int
 }
 var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
-// the range represents integer values 0, 1, and 2
+// 该区间表示整数0，1，2
 rangeOfThreeItems.firstValue = 6
-// the range now represents integer values 6, 7, and 8
+// 该区间现在表示整数6，7，8
 
 ```
 
-`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被赋值，因为它是一个常量存储属性，所以无法修改它的值。
+`FixedLengthRange`的实例包含一个名为`firstValue`的变量存储属性和一个名为`length`的常量存储属性。在上面的例子中，`length`在创建实例的时候被赋值，因为它是一个常量存储属性，所以之后无法修改它的值。
 
 
 ### 常量和存储属性
@@ -46,13 +50,13 @@ rangeOfThreeItems.firstValue = 6
 
 ```
 let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
-// this range represents integer values 0, 1, 2, and 3
+// 该区间表示整数0，1，2，3
 rangeOfFourItems.firstValue = 6
-// this will report an error, even thought firstValue is a variable property
+// 尽管firstValue诗歌变量属性，这里还是会报错
 
 ```
 
-因为`rangeOfFourItems`声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改属性它的值。
+因为`rangeOfFourItems`声明成了常量（用`let`关键字），即使`firstValue`是一个变量属性，也无法再修改它了。
 
 这种行为是由于结构体（struct）属于*值类型*。当值类型的实例被声明为常量的时候，它的所有属性也就成了常量。
 
@@ -61,51 +65,51 @@ rangeOfFourItems.firstValue = 6
 
 ### 延迟存储属性
 
-延迟存储属性是指当第一次被调用的时候才有初始值的属性。在属性声明前使用`@lazy`特性来表示一个延迟存储属性。
+延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。在属性声明前使用`@lazy`来标示一个延迟存储属性。
 
-> 注意
-> 
-> 必须将延迟存储属性声明成变量（使用`var`关键字），因为可能在实例构造完成之前属性的值无法得到。常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
+> 注意：
+>
+> 必须将延迟存储属性声明成变量（使用`var`关键字），因为属性的值在实例构造完成之前可能无法得到。而常量属性在构造过程完成之前必须要有初始值，因此无法声明成延迟属性。
 
 延迟属性很有用，当属性的值依赖于在实例的构造过程结束前无法知道具体值的外部因素时，或者当属性的值需要复杂或大量计算时，可以只在需要的时候来计算它。
 
-下面复合类的例子使用了延迟存储属性来避免不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
+下面的例子使用了延迟存储属性来避免复杂类的不必要的初始化。例子中定义了`DataImporter`和`DataManager`两个类，下面是部分代码：
 
 ```
 class DataImporter {
     /*
-    DataImporter is a class to import data from an external file.
-    The class is assumed to take a non-trivial amount of time to initialize.
+    DataImporter 是一个将外部文件中的数据导入的类。
+    这个类的初始化会消耗不少时间。
     */
     var fileName = "data.txt"
-    // the DataImporter class would provide data importing functionality here
+    // 这是提供数据导入功能
 }
- 
+
 class DataManager {
     @lazy var importer = DataImporter()
     var data = String[]()
-    // the DataManager class would provide data management functionality here
+    // 这是提供数据管理功能
 }
- 
+
 let manager = DataManager()
 manager.data += "Some data"
 manager.data += "Some more data"
-// the DataImporter instance for the importer property has not yet been created
+// DataImporter 实例的 importer 属性还没有被创建
 
 ```
 
 `DataManager`类包含一个名为`data`的存储属性，初始值是一个空的字符串（`String`）数组。虽然没有写出全部代码，`DataManager`类的目的是管理和提供对这个字符串数组的访问。
 
-`DataManager`的一个功能是从文件导入数据，该功能由`DataImporter`类提供，它需要一定的时间来处理。因为它需要在实例化之后打开文件、读取文件内容到内存。
+`DataManager`的一个功能是从文件导入数据，该功能由`DataImporter`类提供，`DataImporter`需要消耗不少时间完成初始化：因为它的实例在初始化时可能要打开文件，还要读取文件内容到内存。
 
-`DataManager`也可以不从文件中导入数据，所以当`DataManager`的实例被创建时，就没有必要创建一个`DataImporter`的实例。同时，更有意义的是当用到`DataImporter`的时候才去创建它。
+`DataManager`也可能不从文件中导入数据。所以当`DataManager`的实例被创建时，没必要创建一个`DataImporter`的实例，更明智的是当用到`DataImporter`的时候才去创建它。
 
-由于使用了`@lazy`特性（Attribute），`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时：
+由于使用了`@lazy`，`importer`属性只有在第一次被访问的时候才被创建。比如访问它的属性`fileName`时：
 
 ```
 println(manager.importer.fileName)
-// the DataImporter instance for the importer property has now been created
-// prints "data.txt”
+// DataImporter 实例的 importer 属性现在被创建了
+// 输出 "data.txt”
 
 ```
 
@@ -114,7 +118,7 @@ println(manager.importer.fileName)
 如果您有过 Objective-C 经验，应该知道有两种方式在类实例存储值和引用。对于属性来说，也可以使用实例变量作为属性值的后端存储。
 
 Swift 编程语言中把这些理论统一用属性来实现。Swift 中的属性没有对应的实例变量，属性的后端存储也无法直接访问。这就避免了不同场景下访问方式的困扰，同时也将属性的定义简化成一个语句。
-一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方定义。
+一个类型中属性的全部信息——包括命名、类型和内存管理特征——都在唯一一个地方（类型定义中）定义。
 
 
 ## 计算属性
@@ -148,7 +152,7 @@ var square = Rect(origin: Point(x: 0.0, y: 0.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))")
-// prints "square.origin is now at (10.0, 10.0)”
+// 输出 "square.origin is now at (10.0, 10.0)”
 
 ```
 
@@ -158,13 +162,13 @@ println("square.origin is now at (\(square.origin.x), \(square.origin.y))")
 - `Size`封装了一个`width`和`height`
 - `Rect`表示一个有原点和尺寸的矩形
 
-`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的getter和setter来获取和设置矩形的中心点，就像它有一个存储属性一样。
+`Rect`也提供了一个名为`center`的计算属性。一个矩形的中心点可以从原点和尺寸来算出，所以不需要将它以显式声明的`Point`来保存。`Rect`的计算属性`center`提供了自定义的 getter 和 setter 来获取和设置矩形的中心点，就像它有一个存储属性一样。
 
 例子中接下来创建了一个名为`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`的值，从而实现移动正方形到新的位置。
 
 Computed Properties sample
 
@@ -196,8 +200,8 @@ struct AlternativeRect {
 
 只有 getter 没有 setter 的计算属性就是*只读计算属性*。只读计算属性总是返回一个值，可以通过点运算符访问，但不能设置新的值。
 
-> 注意
-> 
+> 注意：
+>
 > 必须使用`var`关键字定义计算属性，包括只读计算属性，因为他们的值不是固定的。`let`关键字只用来声明常量属性，表示初始化后再也无法修改的值。
 
 只读计算属性的声明可以去掉`get`关键字和花括号：
@@ -211,23 +215,21 @@ struct Cuboid {
 }
 let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
 println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
-// prints "the volume of fourByFiveByTwo is 40.0"
+// 输出 "the volume of fourByFiveByTwo is 40.0"
 
 ```
 
-这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性，还有一个名为`volume`的只读计算属性用来返回立方体的体积，设置`volume`的值毫无意义，因为无法确定`width`、`height`和`depth`的值。
-
-尽管如此，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
+这个例子定义了一个名为`Cuboid`的结构体，表示三维空间的立方体，包含`width`、`height`和`depth`属性，还有一个名为`volume`的只读计算属性用来返回立方体的体积。设置`volume`的值毫无意义，因为通过`width`、`height`和`depth`就能算出`volume`。然而，`Cuboid`提供一个只读计算属性来让外部用户直接获取体积是很有用的。
 
 
 ## 属性监视器
 
 *属性监视器*监控和响应属性值的变化，每次属性被设置值的时候都会调用属性监视器，甚至新的值和现在的值相同的时候也不例外。
 
-可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载详见[重载](chapter/13_Inheritance.html#overriding)一节。
+可以为除了延迟存储属性之外的其他存储属性添加属性监视器，也可以通过重载属性的方式为继承的属性（包括存储属性和计算属性）添加属性监视器。属性重载请参考[继承](chapter/13_Inheritance.html)一章的[重载](chapter/13_Inheritance.html#overriding)。
 
-> 注意
-> 
+> 注意：
+>
 > 不需要为无法重载的计算属性添加属性监视器，因为可以通过 setter 直接监控和响应值的变化。
 
 可以为属性添加如下的一个或全部监视器：
@@ -239,8 +241,8 @@ println("the volume of fourByFiveByTwo is \(fourByFiveByTwo.volume)")
 
 类似地，`didSet`监视器会将旧的属性值作为参数传入，可以为该参数命名或者使用默认参数名`oldValue`。
 
-> 注意
-> 
+> 注意：
+>
 > `willSet`和`didSet`监视器在属性初始化过程中不会被调用，他们只会当属性的值在初始化之外的地方被设置时被调用。
 
 这里是一个`willSet`和`didSet`的实际例子，其中定义了一个名为`StepCounter`的类，用来统计当人步行时的总步数，可以跟计步器或其他日常锻炼的统计装置的输入数据配合使用。
@@ -279,92 +281,92 @@ stepCounter.totalSteps = 896
 
 `didSet`监视器在`totalSteps`的值改变后被调用，它把新的值和旧的值进行对比，如果总的步数增加了，就输出一个消息表示增加了多少步。`didSet`没有提供自定义名称，所以默认值`oldValue`表示旧值的参数名。
 
-> 注意
-> 
+> 注意：
+>
 > 如果在`didSet`监视器里为属性赋值，这个值会替换监视器之前设置的值。
 
 
 ##全局变量和局部变量
 
-计算属性和属性监视器所描述的模式也可以用于全局变量和局部变量，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。
+计算属性和属性监视器所描述的模式也可以用于*全局变量*和*局部变量*，全局变量是在函数、方法、闭包或任何类型之外定义的变量，局部变量是在函数、方法或闭包内部定义的变量。
 
 前面章节提到的全局或局部变量都属于存储型变量，跟存储属性类似，它提供特定类型的存储空间，并允许读取和写入。
 
 另外，在全局或局部范围都可以定义计算型变量和为存储型变量定义监视器，计算型变量跟计算属性一样，返回一个计算的值而不是存储值，声明格式也完全一样。
 
-> 注意
-> 
+> 注意：
+>
 > 全局的常量或变量都是延迟计算的，跟[延迟存储属性](#lazy_stored_properties)相似，不同的地方在于，全局的常量或变量不需要标记`@lazy`特性。
-> 
+>
 > 局部范围的常量或变量不会延迟计算。
 
 
-##类属性
+##类型属性
 
 实例的属性属于一个特定类型实例，每次类型实例化后都拥有自己的一套属性值，实例之间的属性相互独立。
 
-也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是*类属性*。
+也可以为类型本身定义属性，不管类型有多少个实例，这些属性都只有唯一一份。这种属性就是*类型属性*。
 
-类属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
+类型属性用于定义特定类型所有实例共享的数据，比如所有实例都能用的一个常量（就像 C 语言中的静态常量），或者所有实例都能访问的一个变量（就像 C 语言中的静态变量）。
 
-对于值类型（指结构体和枚举）可以定义存储型和计算型类属性，对于类（class）则只能定义计算型类属性。
+对于值类型（指结构体和枚举）可以定义存储型和计算型类型属性，对于类（class）则只能定义计算型类型属性。
 
-值类型的存储型类属性可以是变量或常量，计算型类属性跟实例的计算属性一样定义成变量属性。
+值类型的存储型类型属性可以是变量或常量，计算型类型属性跟实例的计算属性一样定义成变量属性。
 
-> 注意
-> 
-> 跟实例的存储属性不同，必须给存储型类属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类属性赋值。
+> 注意：
+>
+> 跟实例的存储属性不同，必须给存储型类型属性指定默认值，因为类型本身无法在初始化过程中使用构造器给类型属性赋值。
 
 
-###类属性语法
+###类型属性语法
 
-在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上`global`关键字。在 Swift 编程语言中，类属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
+在 C 或 Objective-C 中，静态常量和静态变量的定义是通过特定类型加上`global`关键字。在 Swift 编程语言中，类型属性是作为类型定义的一部分写在类型最外层的花括号内，因此它的作用范围也就在类型支持的范围内。
 
-使用关键字`static`来定义值类型的类属性，关键字`class`来为类（class）定义类属性。下面的例子演示了存储型和计算型类属性的语法：
+使用关键字`static`来定义值类型的类型属性，关键字`class`来为类（class）定义类型属性。下面的例子演示了存储型和计算型类型属性的语法：
 
 ```
 struct SomeStructure {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
 enum SomeEnumeration {
     static var storedTypeProperty = "Some value."
     static var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
 class SomeClass {
     class var computedTypeProperty: Int {
-    // return an Int value here
+    // 这里返回一个 Int 值
     }
 }
 
 ```
 
-> 注意
-> 
-> 例子中的计算型类属性是只读的，但也可以定义可读可写的计算型类属性，跟实例计算属性的语法类似。
+> 注意：
+>
+> 例子中的计算型类型属性是只读的，但也可以定义可读可写的计算型类型属性，跟实例计算属性的语法类似。
 
 
-###获取和设置类属性的值
+###获取和设置类型属性的值
 
-跟实例的属性一样，类属性的访问也是通过点运算符来进行，但是，类属性是通过类型本身来获取和设置，而不是通过实例。比如：
+跟实例的属性一样，类型属性的访问也是通过点运算符来进行，但是，类型属性是通过类型本身来获取和设置，而不是通过实例。比如：
 
 ```
 println(SomeClass.computedTypeProperty)
-// prints "42"
- 
+// 输出 "42"
+
 println(SomeStructure.storedTypeProperty)
-// prints "Some value."
+// 输出 "Some value."
 SomeStructure.storedTypeProperty = "Another value."
 println(SomeStructure.storedTypeProperty)
-// prints "Another value.”
+// 输出 "Another value.”
 
 ```
 
-下面的例子定义了一个结构体，使用两个存储型类属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。
+下面的例子定义了一个结构体，使用两个存储型类型属性来表示多个声道的声音电平值，每个声道有一个 0 到 10 之间的整数表示声音电平值。
 
 后面的图表展示了如何联合使用两个声道来表示一个立体声的声音电平值。当声道的电平值是 0，没有一个灯会亮；当声道的电平值是 10，所有灯点亮。本图中，左声道的电平是 9，右声道的电平是 7。
 
@@ -379,11 +381,11 @@ struct AudioChannel {
     var currentLevel: Int = 0 {
     didSet {
         if currentLevel > AudioChannel.thresholdLevel {
-            // cap the new audio level to the threshold level
+            // 将新电平值设置为阀值
             currentLevel = AudioChannel.thresholdLevel
         }
         if currentLevel > AudioChannel.maxInputLevelForAllChannels {
-            // store this as the new overall maximum input level
+            // 存储当前电平值作为新的最大输入电平
             AudioChannel.maxInputLevelForAllChannels = currentLevel
         }
     }
@@ -392,9 +394,9 @@ struct AudioChannel {
 
 ```
 
-结构`AudioChannel`定义了 2 个存储型类属性来实现上述功能。第一个是`thresholdLevel`，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。
+结构`AudioChannel`定义了 2 个存储型类型属性来实现上述功能。第一个是`thresholdLevel`，表示声音电平的最大上限阈值，它是一个取值为 10 的常量，对所有实例都可见，如果声音电平高于 10，则取最大上限值 10（见后面描述）。
 
-第二个类属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的电平值的最大值，初始值是 0。
+第二个类型属性是变量存储型属性`maxInputLevelForAllChannels`，它用来表示所有`AudioChannel`实例的电平值的最大值，初始值是 0。
 
 `AudioChannel`也定义了一个名为`currentLevel`的实例存储属性，表示当前声道现在的电平值，取值为 0 到 10。
 
@@ -403,11 +405,11 @@ struct AudioChannel {
 - 如果`currentLevel`的新值大于允许的阈值`thresholdLevel`，属性监视器将`currentLevel`的值限定为阈值`thresholdLevel`。
 - 如果修正后的`currentLevel`值大于任何之前任意`AudioChannel`实例中的值，属性监视器将新值保存在静态属性`maxInputLevelForAllChannels`中。
 
-> 注意
-> 
-> 在第一个检查过程中，`didSet`属性监视器将`currentLevel`设置成了不同的值，但这不会再次调用属性监视器。
+> 注意：
+>
+> 在第一个检查过程中，`didSet`属性监视器将`currentLevel`设置成了不同的值，但这时不会再次调用属性监视器。
 
-可以使用结构`AudioChannel`来创建表示立体声系统的两个声道`leftChannel`和`rightChannel`：
+可以使用结构体`AudioChannel`来创建表示立体声系统的两个声道`leftChannel`和`rightChannel`：
 
 ```
 var leftChannel = AudioChannel()
@@ -415,14 +417,14 @@ var rightChannel = AudioChannel()
 
 ```
 
-如果将左声道的电平设置成 7，类属性`maxInputLevelForAllChannels`也会更新成 7：
+如果将左声道的电平设置成 7，类型属性`maxInputLevelForAllChannels`也会更新成 7：
 
 ```
 leftChannel.currentLevel = 7
 println(leftChannel.currentLevel)
-// prints "7"
+// 输出 "7"
 println(AudioChannel.maxInputLevelForAllChannels)
-// prints "7”
+// 输出 "7"
 
 ```
 
@@ -431,8 +433,8 @@ println(AudioChannel.maxInputLevelForAllChannels)
 ```
 rightChannel.currentLevel = 11
 println(rightChannel.currentLevel)
-// prints "10"
+// 输出 "10"
 println(AudioChannel.maxInputLevelForAllChannels)
-// prints "10”
+// 输出 "10"
 
-```
\ No newline at end of file
+```
diff --git a/source/chapter2/11_Methods.md b/source/chapter2/11_Methods.md
index d090d756..795b54db 100644
--- a/source/chapter2/11_Methods.md
+++ b/source/chapter2/11_Methods.md
@@ -1,17 +1,28 @@
+> 翻译：pp-prog
+
+> 校对：地
+
 # 方法（Methods）
 -----------------
 
-**方法**是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型自身相关联。类型方法与Objective-C中的类方法(class methods)相似。
 
-在Swift中,结构体和枚举能够定义方法；事实上这是Swift与C/Objective-C的主要区别之一。在Objective-C中,类是唯一能定义方法的类型。但在Swift中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型(类/结构体/枚举)上定义方法。
+本页包含内容：
 
-### 实例方法(Instance Methods)
+-   [实例方法(Instance Methods](#instance_methods)
+-   [类型方法(Type Methods)](#type_methods)
 
-**实例方法**是某个特定类、结构体或者枚举类型的实例的方法。实例方法支撑实例的功能: 或者提供方法,以访问和修改实例属性;或者提供与实例的目的相关的功能。实例方法的语法与函数完全一致，你可以参考[函数](../charpter2/06_Functions.md)。
+**方法**是与某些特定类型相关联的函数。类、结构体、枚举都可以定义实例方法；实例方法为给定类型的实例封装了具体的任务与功能。类、结构体、枚举也可以定义类型方法；类型方法与类型本身相关联。类型方法与 Objective-C 中的类方法（class methods）相似。
+
+结构体和枚举能够定义方法是 Swift 与 C/Objective-C 的主要区别之一。在 Objective-C 中，类是唯一能定义方法的类型。但在 Swift 中，你不仅能选择是否要定义一个类/结构体/枚举，还能灵活的在你创建的类型（类/结构体/枚举）上定义方法。
+
+
+## 实例方法(Instance Methods)
+
+**实例方法**是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见[函数](../charpter2/06_Functions.md)。
 
 实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。
 
-下面的例子，定义一个很简单的类`Counter`，`Counter`能被用来对一个动作发生的次数进行计数:
+下面的例子，定义一个很简单的类`Counter`，`Counter`能被用来对一个动作发生的次数进行计数：
 
 ```
 class Counter {
@@ -35,28 +46,28 @@ class Counter {
 
 `Counter`这个类还声明了一个可变属性`count`，用它来保持对当前计数器值的追踪。
 
-和调用属性一样，用点语法(dot syntax)调用实例方法:
+和调用属性一样，用点语法（dot syntax）调用实例方法：
 
 ```
  let counter = Counter()
- // the initial counter value is 0
+ // 初始计数值是0
  counter.increment()
- // the counter's value is now 1
+ // 计数值现在是1
  counter.incrementBy(5)
- // the counter's value is now 6
+ // 计数值现在是6
  counter.reset()
- // the counter's value is now 0
+ // 计数值现在是0
 ```
-
+
 ### 方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)
 
-函数参数可以同时有一个局部名称(在函数体内部使用)和一个外部名称(在调用函数时使用),参考[函数的外部参数名](../06_Functions.md)。方法参数也一样(因为方法就是函数，只是这个函数与某个类型相关联了)。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。
+函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见[函数的外部参数名](06_Functions.html)。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。
 
-Swift中的方法和Objective-C中的方法极其相似。像在Objective-C中一样，Swift中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`,`for`,`by`等等。前面的`Counter`类的例子中`incrementBy`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。Swift这种方法命名约定让书写代码更容易了,因为Swift依靠对方法参数不同的默认处理方式，而不是靠函数参数，来实现方法命名。
+Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：`with`，`for`，`by`等等。前面的`Counter`类的例子中`incrementBy`方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。
 
-具体来说，Swift默认仅给方法的第一个参数名称一个局部参数名称;但是默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，这与你在写Objective-C的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
+具体来说，Swift  默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。
 
-看看下面这个`Counter`的替换版本（它定义了一个更复杂的`incrementBy`方法）：
+看看下面这个`Counter`的另一个版本（它定义了一个更复杂的`incrementBy`方法）：
 
 ```
 class Counter {
@@ -67,7 +78,7 @@ class Counter {
 }
 ```
 
-`incrementBy`方法有两个参数： `amount`和`numberOfTimes`。默认地，Swift只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作本地名称又看作外部名称。下面调用这个方法：
+`incrementBy`方法有两个参数： `amount`和`numberOfTimes`。默认情况下，Swift 只把`amount`当作一个局部名称，但是把`numberOfTimes`即看作局部名称又看作外部名称。下面调用这个方法：
 
 ```
 let counter = Counter()
@@ -75,9 +86,9 @@ counter.incrementBy(5, numberOfTimes: 3)
 // counter value is now 15
 ```
 
-你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy`已经能很清楚地看出它的目的/作用。但是第二个参数，就要被一个外部参数名称所限定,以便在方法被调用时让他目的/作用明确。
+你不必为第一个参数值再定义一个外部变量名：因为从函数名`incrementBy`已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。
 
-这种默认的行为能够有效的处理方法，比如你在参数numberOfTimes前写了个井号( `#` )时:
+这种默认的行为能够有效的处理方法（method）,类似于在参数`numberOfTimes`前写一个井号（`#`）：
 
 ```
 func incrementBy(amount: Int, #numberOfTimes: Int) {
@@ -85,15 +96,17 @@ func incrementBy(amount: Int, #numberOfTimes: Int) {
 }
 ```
 
-这种默认行为使上面代码意味着：在Swift中定义方法使用了与Objective-C同样的语法风格，并且方法将以自然表达式的方式被调用。
+这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。
 
+
 ### 修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)
 
-有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称;你也可以用一个hash符号作为第一个参数的前缀，把这个局部名称呢更作为外部名称。
+有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（`#`）作为第一个参数的前缀来把这个局部名称当作外部名称使用。
 
-相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，你可以通过使用下划线(`_`)作为该参数的显式外部名称来覆盖默认行为。
+相反，如果你不想为方法的第二个及后续的参数提供一个外部名称，可以通过使用下划线（`_`）作为该参数的显式外部名称，这样做将覆盖默认行为。
 
-### `self`属性(The self Property)
+
+## `self`属性(The self Property)
 
 类型的每一个实例都有一个隐含属性叫做`self`，`self`完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的`self`属性来引用当前实例。
 
@@ -104,9 +117,9 @@ func increment() {
 }
 ```
 
-实际上，你不必在你的代码里面经常写`self`。不论何时，在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写`self`，Swift假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`(而不是`self.count`)
+实际上，你不必在你的代码里面经常写`self`。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写`self`，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的`Counter`中已经示范了：`Counter`中的三个实例方法中都使用的是`count`（而不是`self.count`）。
 
-这条规则的主要例外发生在当实例方法的某个参数名称与实例的某个属性名称相同时。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更恰当(被限定更严格)的方式。你可以使用`self`属性来区分参数名称和属性名称。
+使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用`self`属性来区分参数名称和属性名称。
 
 下面的例子中，`self`消除方法参数`x`和实例属性`x`之间的歧义：
 
@@ -121,18 +134,19 @@ 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")
 }
-// prints "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这条线的右边）
 ```
 
-如果不使用`self`前缀，Swift就认为两次使用的`x`都指的是名称为`x`的函数参数。
+如果不使用`self`前缀，Swift 就认为两次使用的`x`都指的是名称为`x`的函数参数。
 
+
 ### 在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)
 
 结构体和枚举是**值类型**。一般情况下，值类型的属性不能在它的实例方法中被修改。
 
-但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择`变异(mutating)`这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时都会回写到原始结构。方法还可以给它隐含的`self`属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。
+但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择`变异(mutating)`这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的`self`属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。
 
-要`变异`方法, 将关键字`mutating` 放到方法的`func`关键字之前就可以了：
+要使用`变异`方法， 将关键字`mutating` 放到方法的`func`关键字之前就可以了：
 
 ```
 struct Point {
@@ -145,18 +159,19 @@ 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))")
-// prints "The point is now at (3.0, 4.0)"
+// 输出 "The point is now at (3.0, 4.0)"
 ```
 
-上面的Point结构体定义了一个变异方法(mutating method)`moveByX`，`moveByX`用来移动一个point。`moveByX`方法在被调用时修改了这个point,而不是返回一个新的point。方法定义时加上`mutating`关键字,这才让方法可以修改值类型的属性了。
+上面的`Point`结构体定义了一个变异方法（mutating method）`moveByX`，`moveByX`用来移动点。`moveByX`方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上`mutating`关键字,这才让方法可以修改值类型的属性。
 
-注意：不能在结构体类型的常量上调用变异方法,因为常量的属性不能被改变,就算你想改变的是常量的可变属性也不行，参考[存储属性和实例变量]("../10_Properties")
+注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见[存储属性和实例变量]("10_Properties.html")
 
 ```
 let fixedPoint = Point(x: 3.0, y: 3.0)
 fixedPoint.moveByX(2.0, y: 3.0)
 // this will report an error
 ```
+
 ### 在变异方法中给self赋值(Assigning to self Within a Mutating Method)
 
 变异方法能够赋给隐含属性`self`一个全新的实例。上面`Point`的例子可以用下面的方式改写：
@@ -170,9 +185,9 @@ struct Point {
 }
 ```
 
-新版的变异方法`moveByX`创建了一个新的结构(它的x和y的值都被设定为目标值了)。调用这个版本的方法和调用上个版本的最终结果是一样的。
+新版的变异方法`moveByX`创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。
 
-枚举的变异方法可以让`self`从相同的枚举设置为不同的成员：
+枚举的变异方法可以把`self`设置为相同的枚举类型中不同的成员：
 
 ```
 enum TriStateSwitch {
@@ -190,22 +205,23 @@ enum TriStateSwitch {
 }
 var ovenLight = TriStateSwitch.Low
 ovenLight.next()
-// ovenLight is now equal to .High
+// ovenLight 现在等于 .High
 ovenLight.next()
-// ovenLight is now equal to .Off
+// ovenLight 现在等于 .Off
 ```
 
-上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态(`Off`,`Low`,`High`)之前循环切换。
+上面的例子中定义了一个三态开关的枚举。每次调用`next`方法时，开关在不同的电源状态（`Off`，`Low`，`High`）之前循环切换。
 
-### 类型方法(Type Methods)
+
+## 类型方法(Type Methods)
 
-实例方法是被类型的某个实例调用的方法。你也可以定义类列本身调用的方法，这种方法就叫做**类型方法**。声明类的类型方法，在方法的`func`关键字之前加上关键字`class`；声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。
+实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做**类型方法**。声明类的类型方法，在方法的`func`关键字之前加上关键字`class`；声明结构体和枚举的类型方法，在方法的`func`关键字之前加上关键字`static`。
 
 > 注意：
 
-> 在Objective-C里面，你只能为Objective-C的类定义类型方法(type-level methods)。在Swift中，你可以为所有的类、结构体和枚举定义类型方法：Each type method is explicitly scoped to the type it supports.
+> 在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。
 
-类型方法和实例方法一样用点语法调用。但是，你是在类型上调用这个方法，而不是在实例上调用。下面是如何在SomeClass类上调用类型方法的例子：
+类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在`SomeClass`类上调用类型方法的例子：
 
 ```
 class SomeClass {
@@ -216,13 +232,13 @@ class SomeClass {
 SomeClass.someTypeMethod()
 ```
 
-在类型方法的方法体(body)中，`self`指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用`self`来消除静态属性和静态方法参数之间的二意性(类似于我们在前面处理实例属性和实例方法参数时做的那样)。
+在类型方法的方法体（body）中，`self`指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用`self`来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。
 
-一般地，在类型方法里面所使用的任何未限定的方法和属性名称，将会指向其他的类型级别的方法和属性。一个类型方法可以用另一个类型方法的名称调用踏，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。
+一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。
 
-下面的例子定义了一个名为`LevelTracker`结构体。它监测玩家的发展情况(游戏的不同层次或阶段)。这是一个单人游戏，但也可以用作多玩家游戏中单个设备上的信息存储。
+下面的例子定义了一个名为`LevelTracker`结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。
 
-游戏初始时，所有的游戏等级(除了等级1)都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。他还监测每个玩家的当前等级。
+游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。`LevelTracker`结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。
 
 ```
 struct LevelTracker {
@@ -247,11 +263,11 @@ struct LevelTracker {
 
 `LevelTracker`监测玩家的已解锁的最高等级。这个值被存储在静态属性`highestUnlockedLevel`中。
 
-`LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`：一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`：如果某个给定的等级已经被解锁，他返回`true`。(注意：我们没用使用`LevelTracker.highestUnlockedLevel`，这个类型方法还是能够访问静态属性`highestUnlockedLevel`)
+`LevelTracker`还定义了两个类型方法与`highestUnlockedLevel`配合工作。第一个类型方法是`unlockLevel`：一旦新等级被解锁，它会更新`highestUnlockedLevel`的值。第二个类型方法是`levelIsUnlocked`：如果某个给定的等级已经被解锁，它将返回`true`。（注意：尽管我们没有使用类似`LevelTracker.highestUnlockedLevel`的写法，这个类型方法还是能够访问静态属性`highestUnlockedLevel`）
 
-除了静态属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测玩家当前正在进行的等级。
+除了静态属性和类型方法，`LevelTracker`还监测每个玩家的进度。它用实例属性`currentLevel`来监测玩家当前的等级。
 
-为了便于管理`currentLevel`属性，`LevelTracker`定义了实例方法`advanceToLevel`。这个方法会在更新`currentLevel`之前检查所请求的新等级是否已经解锁。`advanceToLevel`方法返回布尔值以指示是否确实能够设置`currentLevel`了。
+为了便于管理`currentLevel`属性，`LevelTracker`定义了实例方法`advanceToLevel`。这个方法会在更新`currentLevel`之前检查所请求的新等级是否已经解锁。`advanceToLevel`方法返回布尔值以指示是否能够设置`currentLevel`。
 
 下面，`Player`类使用`LevelTracker`来监测和更新每个玩家的发展进度：
 
@@ -269,7 +285,7 @@ class Player {
 }
 ```
 
-`Player`类创建一个新的`LevelTracker`实例来检测这个用户的发展进度。他提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）
+`Player`类创建一个新的`LevelTracker`实例来监测这个用户的发展进度。他提供了`completedLevel`方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了`advanceToLevel`返回的布尔值，因为之前调用`LevelTracker.unlockLevel`时就知道了这个等级已经被解锁了）。
 
 你还可以为一个新的玩家创建一个`Player`的实例，然后看这个玩家完成等级一时发生了什么：
 
@@ -277,10 +293,11 @@ class Player {
 var player = Player(name: "Argyrios")
 player.completedLevel(1)
 println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)")
-// prints "highest unlocked level is now 2"
+// 输出 "highest unlocked level is now 2"（最高等级现在是2
+）
 ```
 
-如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，当你试图去设置玩家当前等级时会失败的：
+如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：
 
 ```
 player = Player(name: "Beto")
@@ -289,5 +306,5 @@ println("player is now on level 6")
 } else {
 println("level 6 has not yet been unlocked")
 }
-// prints "level 6 has not yet been unlocked"
+// 输出 "level 6 has not yet been unlocked"（等级6还没被解锁）
 ```
diff --git a/source/chapter2/12_Subscripts.md b/source/chapter2/12_Subscripts.md
index f35bc5d7..79b4b7a5 100644
--- a/source/chapter2/12_Subscripts.md
+++ b/source/chapter2/12_Subscripts.md
@@ -1,16 +1,27 @@
-# 下标（Subscripts）
+> 翻译：siemenliu
+
+> 校对：zq54zquan
+
+
+# 附属脚本（Subscripts）
 -----------------
 
-下标可以定义在类(Class)、结构体(structures)和枚举(enumerations)这些目标中，可以认为是访问对象、集合或序列的快捷方式。举例来说，用下标访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`，而不需要再调用实例的某个方法来获得元素的值。
+本页包含内容：
 
-对于同一个目标可以定义多个下标，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。
+- [附属脚本语法](#subscript_syntax)
+- [附属脚本用法](#subscript_usage)
+- [附属脚本选项](#subscript_options)
 
-> 译者：这里下标重载在本小节中原文并没有任何演示
+*附属脚本* 可以定义在类（Class）、结构体（structure）和枚举（enumeration）这些目标中，可以认为是访问对象、集合或序列的快捷方式，不需要再调用实例的特定的赋值和访问方法。举例来说，用附属脚本访问一个数组(Array)实例中的元素可以这样写 `someArray[index]` ，访问字典(Dictionary)实例中的元素可以这样写 `someDictionary[key]`。
 
+对于同一个目标可以定义多个附属脚本，通过索引值类型的不同来进行重载，而且索引值的个数可以是多个。
 
-## 下标语法
+> 译者：这里附属脚本重载在本小节中原文并没有任何演示
 
-下标允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和实例属性的混合。与定义实例方法类似，定义下标使用`subscript`关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是下标可以设定为读写或只读。这种方式又有点像实例属性的getter和setter：
+
+## 附属脚本语法
+
+附属脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似，定义附属脚本使用`subscript`关键字，显式声明入参（一个或多个）和返回类型。与实例方法不同的是附属脚本可以设定为读写或只读。这种方式又有点像计算型属性的getter和setter：
 
 ```
 subscript(index: Int) -> Int {
@@ -24,9 +35,9 @@ subscript(index: Int) -> Int {
 }
 ```
 
-`newValue`的类型必须和下标定义的返回类型相同。与实例属性相同的是set的入参声明`newValue`就算不写，在set代码块中依然可以使用`newValue`这个变量来访问新赋的值。
+`newValue`的类型必须和附属脚本定义的返回类型相同。与计算型属性相同的是set的入参声明`newValue`就算不写，在set代码块中依然可以使用默认的`newValue`这个变量来访问新赋的值。
 
-与只读实例属性一样，可以直接将原本应该写在get代码块中的代码写在subscript中即可：
+与只读计算型属性一样，可以直接将原本应该写在`get`代码块中的代码写在`subscript`中：
 
 ```
 subscript(index: Int) -> Int {
@@ -34,7 +45,7 @@ subscript(index: Int) -> Int {
 }
 ```
 
-下面代码演示了一个在TimesTable结构体中使用只读下标的用法，该结构体用来展示传入整数的N倍。
+下面代码演示了一个在`TimesTable`结构体中使用只读附属脚本的用法，该结构体用来展示传入整数的*n*倍。
 
 ```
 struct TimesTable {
@@ -48,42 +59,43 @@ println("3的6倍是\(threeTimesTable[6])")
 // 输出 "3的6倍是18"
 ```
 
-在上例中，通过TimesTable结构体创建了一个用来表示索引值三倍的实例。数值3作为结构体构造函数入参表示这个值将成为实例成员multiplier的值。
+在上例中，通过`TimesTable`结构体创建了一个用来表示索引值三倍的实例。数值`3`作为结构体`构造函数`入参初始化实例成员`multiplier`。
 
-你可以通过下标来来得到结果，比如`threeTimesTable[6]`。这句话访问了threeTimesTable的第六个元素，返回18或者6的3倍。
+你可以通过附属脚本来来得到结果，比如`threeTimesTable[6]`。这句话访问了`threeTimesTable`的第六个元素，返回`18`或者`6`的`3`倍。
 
-> 提示
-> 
-> TimesTable例子是基于一个固定的数学公式。它并不适合开放写权限来对threeTimesTable[someIndex]进行赋值操作，这也是为什么下标只定义为只读的原因。
+>注意：
+>
+> `TimesTable`例子是基于一个固定的数学公式。它并不适合开放写权限来对`threeTimesTable[someIndex]`进行赋值操作，这也是为什么附属脚本只定义为只读的原因。
 
 
-## 下标用法
+
+## 附属脚本用法
 
-下标根据使用场景不同也具有不同的含义。通常下标是用来访问集合(collection)，列表(list)或序列(sequence)中元素的快捷方式。你可以为特定的类或结构体中自由的实现下标来提供合适的功能。
+根据使用场景不同附属脚本也具有不同的含义。通常附属脚本是用来访问集合（collection），列表（list）或序列（sequence）中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现附属脚本来提供合适的功能。
 
-例如，Swift的字典(Dictionary)实现了通过下标来对其实例中存放的值进行存取操作。在字典中设值可以通过给字典提供一个符合字典索引类型的索引值的表达式赋一个与字典存放值类型匹配的值来做到：
+例如，Swift 的字典（Dictionary）实现了通过附属脚本来对其实例中存放的值进行存取操作。在附属脚本中使用和字典索引相同类型的值，并且把一个字典值类型的值赋值给这个附属脚本来为字典设值：
 
 ```
 var numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
 numberOfLegs["bird"] = 2
 ```
 
-上例定义一个名为numberOfLegs的变量并用一个字典表达式初始化出了包含三对键值的字典实例。numberOfLegs的字典存放值类型推断为`Dictionary`。字典实例创建完成之后通过下标的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
+上例定义一个名为`numberOfLegs`的变量并用一个字典字面量初始化出了包含三对键值的字典实例。`numberOfLegs`的字典存放值类型推断为`Dictionary`。字典实例创建完成之后通过附属脚本的方式将整型值`2`赋值到字典实例的索引为`bird`的位置中。
 
-更多关于字典(Dictionary)下标的信息请参考[字典的访问与修改](#)
+更多关于字典（Dictionary）附属脚本的信息请参考[读取和修改字典](../chapter2/04_Collection_Types.html)
 
-> 提示
+> 注意：
 >
-> Swift中Dictionary的下标实现中，在get部分返回值是`Int?`，也就是说不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。
+> Swift 中字典的附属脚本实现中，在`get`部分返回值是`Int?`，上例中的`numberOfLegs`字典通过下边返回的是一个`Int?`或者说“可选的int”，不是每个字典的索引都能得到一个整型值，对于没有设过值的索引的访问返回的结果就是`nil`；同样想要从字典实例中删除某个索引下的值也只需要给这个索引赋值为`nil`即可。
 
+
+## 附属脚本选项
 
-## 下标选项
+附属脚本允许任意数量的入参索引，并且每个入参类型也没有限制。附属脚本的返回值也可以是任何类型。附属脚本可以使用变量参数和可变参数，但使用写入读出（in-out）参数或给参数设置默认值都是不允许的。
 
-下标允许任意数量的入参索引，并且每个入参类型也没有限制。下标的返回值也可以是任何类型。下标可以使用变量参数和可变参数，但使用in-out参数或给参数设置默认值都是不允许的。
+一个类或结构体可以根据自身需要提供多个附属脚本实现，在定义附属脚本时通过入参个类型进行区分，使用附属脚本时会自动匹配合适的附属脚本实现运行，这就是*附属脚本的重载*。
 
-一个类或结构体可以根据自身需要提供多个下标实现，在定义下标时通过入参个类型进行区分，使用下标时会自动匹配合适的下标实现运行，这就是下标的重载。
-
-一个下标入参是最常见的情况，但只要有合适的场景也可以定义多个下标入参。如下例定义了一个Matrix结构体，将呈现一个Double类型的二维数组。Matrix结构体的下标需要两个整型参数：
+一个附属脚本入参是最常见的情况，但只要有合适的场景也可以定义多个附属脚本入参。如下例定义了一个`Matrix`结构体，将呈现一个`Double`类型的二维矩阵。`Matrix`结构体的附属脚本需要两个整型参数：
 
 ```
 struct Matrix {
@@ -110,15 +122,15 @@ struct Matrix {
 }
 ```
 
-Matrix提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳rows * columns个数的Double类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考[Creating and Initializing an Array](#)。
+`Matrix`提供了一个两个入参的构造方法，入参分别是`rows`和`columns`，创建了一个足够容纳`rows * columns`个数的`Double`类型数组。为了存储，将数组的大小和数组每个元素初始值0.0，都传入数组的构造方法中来创建一个正确大小的新数组。关于数组的构造方法和析构方法请参考[创建并且构造一个数组](../chapter2/04_Collection_Types.html)。
 
-你可以通过传入合适的row和column的数量来构造一个新的Matrix实例：
+你可以通过传入合适的`row`和`column`的数量来构造一个新的`Matrix`实例：
 
 ```
 var matrix = Matrix(rows: 2, columns: 2)
 ```
 
-上例中创建了一个新的两行两列的Matrix实例。在阅读顺序从左上到右下的Matrix实例中的数组实例grid是矩阵二维数组的扁平化存储：
+上例中创建了一个新的两行两列的`Matrix`实例。在阅读顺序从左上到右下的`Matrix`实例中的数组实例`grid`是矩阵二维数组的扁平化存储：
 
 ```
 // 示意图
@@ -129,21 +141,21 @@ row0   [0.0, 	0.0,
 row1	0.0, 	0.0]
 ```
 
-将值赋给带有row和column下标的matrix实例表达式可以完成赋值操作，下标入参使用逗号分割
+将值赋给带有`row`和`column`附属脚本的`matrix`实例表达式可以完成赋值操作，附属脚本入参使用逗号分割
 
 ```
 matrix[0, 1] = 1.5
 matrix[1, 0] = 3.2
 ```
 
-上面两句话分别让matrix的右上值为1.5，坐下值为3.2：
+上面两条语句分别`让matrix`的右上值为 1.5，坐下值为 3.2：
 
 ```
 [0.0, 1.5,
  3.2, 0.0]
 ```
 
-Matrix下标的getter和setter中同时调用了下标入参的row和column是否有效的判断。为了方便进行断言，Matrix包含了一个名为indexIsValid的成员方法，用来确认入参的row或column值是否会造成数组越界：
+`Matrix`附属脚本的`getter`和`setter`中同时调用了附属脚本入参的`row`和`column`是否有效的判断。为了方便进行断言，`Matrix`包含了一个名为`indexIsValid`的成员方法，用来确认入参的`row`或`column`值是否会造成数组越界：
 
 ```
 func indexIsValidForRow(row: Int, column: Int) -> Bool {
@@ -151,12 +163,10 @@ func indexIsValidForRow(row: Int, column: Int) -> Bool {
 }
 ```
 
-断言在下标越界时触发：
+断言在附属脚本越界时触发：
 
 ```
 let someValue = matrix[2, 2]
 // 断言将会触发，因为 [2, 2] 已经超过了matrix的最大长度
 ```
 
-> 译者：这里有个词Computed Properties 这里统一翻译为实例属性了 微软术语引擎里没有这个词
-
diff --git a/source/chapter2/13_Inheritance.md b/source/chapter2/13_Inheritance.md
index 11b3371e..69c91a17 100644
--- a/source/chapter2/13_Inheritance.md
+++ b/source/chapter2/13_Inheritance.md
@@ -1,17 +1,31 @@
-# 继承
------------------
+> 翻译：Hawstein
 
-一个类可以继承另一个类的方法，属性和其它特性。当一个类继承其它类，继承类叫子类，被继承类叫超类（或父类）。在Swift中，继承是区分「类」与其它类型的一个基本特征。
+> 校对：menlongsheng
 
-在Swift中，类可以调用和访问超类的方法，属性和下标，并且可以重写（override）这些方法，属性和下标来优化或修改它们的行为。Swift会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
+# 继承（Inheritance）
+-------------------
+
+本页包含内容：
+
+- [定义一个基类（Base class）](#defining_a_base_class)
+- [子类生成（Subclassing）](#subclassing)
+- [重写（Overriding）](#overriding)
+- [防止重写](#preventing_overrides)
+
+一个类可以*继承（inherit）*另一个类的方法（methods），属性（property）和其它特性。当一个类继承其它类时，继承类叫*子类（subclass）*，被继承类叫*超类（或父类，superclass）*。在 Swift 中，继承是区分「类」与其它类型的一个基本特征。
+
+在 Swift 中，类可以调用和访问超类的方法，属性和附属脚本（subscripts），并且可以重写（override）这些方法，属性和附属脚本来优化或修改它们的行为。Swift 会检查你的重写定义在超类中是否有匹配的定义，以此确保你的重写行为是正确的。
 
 可以为类中继承来的属性添加属性观察器（property observer），这样一来，当属性值改变时，类就会被通知到。可以为任何属性添加属性观察器，无论它原本被定义为存储型属性（stored property）还是计算型属性（computed property）。
 
-## 定义一个基类
+
+## 定义一个基类（Base class）
 
-不继承于其它类的类，称之为基类。
+不继承于其它类的类，称之为*基类（base calss）*。
 
-> 注意：Swift中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。
+> 注意：
+>
+Swift 中的类并不是从一个通用的基类继承而来。如果你不为你定义的类指定一个超类的话，这个类就自动成为基类。
 
 下面的例子定义了一个叫`Vehicle`的基类。这个基类声明了两个对所有车辆都通用的属性（`numberOfWheels`和`maxPassengers`）。这些属性在`description`方法中使用，这个方法返回一个`String`类型的，对车辆特征的描述：
 
@@ -29,44 +43,45 @@ class Vehicle {
 }
 ```
 
-`Vehicle`类定义了初始化器（initializer）来设置属性的值。初始化器会在[构造函数]()一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性可以如何被修改。
+`Vehicle`类定义了*构造器（initializer）*来设置属性的值。构造器会在[构造过程](../chapter2/_14Initialization.html)一节中详细介绍，这里我们做一下简单介绍，以便于讲解子类中继承来的属性如何被修改。
 
-初始化器用于创建某个类型的一个新实例。尽管初始化器并不是方法，但在语法上，两者很相似。初始化器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。
+构造器用于创建某个类型的一个新实例。尽管构造器并不是方法，但在语法上，两者很相似。构造器的工作是准备新实例以供使用，并确保实例中的所有属性都拥有有效的初始化值。
 
-初始化器的最简单形式就像一个没有参数的实例方法，使用`init`关键字：
+构造器的最简单形式就像一个没有参数的实例方法，使用`init`关键字：
 
 ```
 init() {
-    // perform some initialization here
+    // 执行构造过程
 }
 ```
 
-如果要创建一个`Vehicle`类的新实例，使用初始化器语法调用上面的初始化器，即类名后面跟一个空的小括号：
+如果要创建一个`Vehicle`类的新实例，使用*构造器*语法调用上面的初始化器，即类名后面跟一个空的小括号：
 
 ```
 let someVehicle = Vehicle()
 ```
 
-这个`Vehicle`类的初始化器为任意的一辆车设置一些初始化属性值（`numberOfWheels = 0 `和`maxPassengers = 1`）。
+这个`Vehicle`类的构造器为任意的一辆车设置一些初始化属性值（`numberOfWheels = 0 `和`maxPassengers = 1`）。
 
 `Vehicle`类定义了车辆的共同特性，但这个类本身并没太大用处。为了使它更为实用，你需要进一步细化它来描述更具体的车辆。
 
-## Subclassing（子类化？待定）
+
+## 子类生成（Subclassing）
 
-subclassing指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且你可以优化或改变它。你还可以为子类添加新的特性。
+*子类生成（Subclassing）*指的是在一个已有类的基础上创建一个新的类。子类继承超类的特性，并且可以优化或改变它。你还可以为子类添加新的特性。
 
 为了指明某个类的超类，将超类名写在子类名的后面，用冒号分隔：
 
 ```
 class SomeClass: SomeSuperclass {
-    // class definition goes here
+    // 类的定义
 }
 ```
-下一个例子，定义一个更具体的车辆类叫`Bicycle`。这个新类是在`Vehicle`类的基础上创建起来。因此你需要将`Vehicle`类放在`Bicycle`类后面，用冒号分隔。
+下一个例子，定义一个更具体的车辆类叫`Bicycle`。这个新类是在 `Vehicle`类的基础上创建起来。因此你需要将`Vehicle`类放在 `Bicycle`类后面，用冒号分隔。
 
 我们可以将这读作：
 
-“定义一个新的类叫`Bicycle`，它继承了`Vehicle`的特性”；
+“定义一个新的类叫`Bicycle `，它继承了`Vehicle`的特性”；
 
 ```
 class Bicycle: Vehicle {
@@ -76,13 +91,15 @@ class Bicycle: Vehicle {
     }
 }
 ```
-`Bicycle`是`Vehicle`的子类，`Vehicle`是`Bicycle`的超类。新的`Bicycle`类自动获得`Vehicle`类的特性，比如`maxPassengers`和`numberOfWheels`属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述`Bicycle`类。
+ `Bicycle`是`Vehicle`的子类，`Vehicle`是`Bicycle`的超类。新的`Bicycle`类自动获得`Vehicle`类的特性，比如 `maxPassengers`和`numberOfWheels`属性。你可以在子类中定制这些特性，或添加新的特性来更好地描述`Bicycle`类。
 
-`Bicycle`类定义了一个初始化器来设置它定制的特性（自行车只有2个轮子）。`Bicycle`的初始化器调用了它父类`Vehicle`的初始化器`super.init()`，以此确保在`Bicycle`类试图修改那些继承来的属性前，`Vehicle`类已经初始化过它们了。
+`Bicycle`类定义了一个构造器来设置它定制的特性（自行车只有2个轮子）。`Bicycle`的构造器调用了它父类`Vehicle`的构造器 `super.init()`，以此确保在`Bicycle`类试图修改那些继承来的属性前`Vehicle`类已经初始化过它们了。
 
-> 注意：不像Objective-C，在Swift中，初始化器默认是不继承的，见[初始化器的继承与重写]()
+> 注意：
+>
+不像 Objective-C，在 Swift 中，初始化器默认是不继承的，见[初始化器的继承与重写](../chapter2/_14Initialization.html#initializer_inheritance_and_ overriding)
 
-`Vehicle`类中`maxPassengers`的默认值对自行车来说已经是正确的，因此在`Bicycle`的初始化器中并没有改变它。而`numberOfWheels`原来的值对自行车来说是不正确的，因此在初始化器中将它更改为2。
+`Vehicle`类中`maxPassengers`的默认值对自行车来说已经是正确的，因此在`Bicycle`的构造器中并没有改变它。而`numberOfWheels`原来的值对自行车来说是不正确的，因此在初始化器中将它更改为 2。
 
 `Bicycle`不仅可以继承`Vehicle`的属性，还可以继承它的方法。如果你创建了一个`Bicycle`类的实例，你就可以调用它继承来的`description`方法，并且可以看到，它输出的属性值已经发生了变化：
 
@@ -103,9 +120,11 @@ class Tandem: Bicycle {
 }
 ```
 
-上面的例子创建了`Bicycle`的一个子类：双人自行车（tandem）。`Tandem`从`Bicycle`继承了两个属性，而这两个属性是`Bicycle`从`Vehicle`继承而来的。`Tandem`并不修改轮子的数量，因为它仍是一辆自行车，有2个轮子。但它需要修改`maxPassengers`的值，因为双人自行车可以坐两个人。
+上面的例子创建了`Bicycle`的一个子类：双人自行车（tandem）。`Tandem`从`Bicycle`继承了两个属性，而这两个属性是`Bicycle`从`Vehicle`继承而来的。`Tandem`并不修改轮子的数量，因为它仍是一辆自行车，有 2 个轮子。但它需要修改`maxPassengers`的值，因为双人自行车可以坐两个人。
 
-> 注意：子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。
+> 注意：
+>
+子类只允许修改从超类继承来的变量属性，而不能修改继承来的常量属性。
 
 创建一个`Tandem`类的实例，打印它的描述，即可看到它的属性已被更新：
 
@@ -117,29 +136,30 @@ println("Tandem: \(tandem.description())")
 
 注意，`Tandem`类也继承了`description`方法。一个类的实例方法会被这个类的所有子类继承。
 
+
 ## 重写（Overriding）
 
-子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或下标（subscript）提供自己定制的实现（implementation）。我们把这种行为叫重写（overriding）。
+子类可以为继承来的实例方法（instance method），类方法（class method），实例属性（instance property），或附属脚本（subscript）提供自己定制的实现（implementation）。我们把这种行为叫*重写（overriding）*。
 
 如果要重写某个特性，你需要在重写定义的前面加上`override`关键字。这么做，你就表明了你是想提供一个重写版本，而非错误地提供了一个相同的定义。意外的重写行为可能会导致不可预知的错误，任何缺少`override`关键字的重写都会在编译时被诊断为错误。
 
-`override`关键字会提醒Swift编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
+`override`关键字会提醒 Swift 编译器去检查该类的超类（或其中一个父类）是否有匹配重写版本的声明。这个检查可以确保你的重写定义是正确的。
 
-### 访问超类的方法，属性及下标
+### 访问超类的方法，属性及附属脚本
 
-当你在子类中重写超类的方法，属性或下标时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
+当你在子类中重写超类的方法，属性或附属脚本时，有时在你的重写版本中使用已经存在的超类实现会大有裨益。比如，你可以优化已有实现的行为，或在一个继承来的变量中存储一个修改过的值。
 
-在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或下标：
+在合适的地方，你可以通过使用`super`前缀来访问超类版本的方法，属性或附属脚本：
 
 * 在方法`someMethod`的重写实现中，可以通过`super.someMethod()`来调用超类版本的`someMethod`方法。
-* 在属性`someProperty`的getter或setter的重写实现中，可以通过`super.someProperty`来访问超类版本的`someProperty`属性。
-* 在下标的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同下标。
+* 在属性`someProperty`的 getter 或 setter 的重写实现中，可以通过`super.someProperty`来访问超类版本的`someProperty`属性。
+* 在附属脚本的重写实现中，可以通过`super[someIndex]`来访问超类版本中的相同附属脚本。
 
 ### 重写方法
 
 在子类中，你可以重写继承来的实例方法或类方法，提供一个定制或替代的方法实现。
 
-下面的例子定义了`Vehicle`的一个新的子类，叫`Car`，它重写了从`Vehicle`类继承来的'description'方法：
+下面的例子定义了`Vehicle`的一个新的子类，叫`Car`，它重写了从`Vehicle`类继承来的`description`方法：
 
 ```
 class Car: Vehicle {
@@ -156,7 +176,7 @@ class Car: Vehicle {
 }
 ```
 
-`Car`声明了一个新的存储型属性`speed`，它是`Double`类型的，默认值是`0.0`，表示“时速是0英里”。'Car'有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。
+`Car`声明了一个新的存储型属性`speed`，它是`Double`类型的，默认值是`0.0`，表示“时速是0英里”。`Car`有自己的初始化器，它将乘客的最大数量设为5，轮子数量设为4。
 
 `Car`重写了继承来的`description`方法，它的声明与`Vehicle`中的`description`方法一致，声明前面加上了`override`关键字。
 
@@ -176,11 +196,13 @@ println("Car: \(car.description())")
 
 #### 重写属性的Getters和Setters
 
-你可以提供定制的getter（或setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
+你可以提供定制的 getter（或 setter）来重写任意继承来的属性，无论继承来的属性是存储型的还是计算型的属性。子类并不知道继承来的属性是存储型的还是计算型的，它只知道继承来的属性会有一个名字和类型。你在重写一个属性时，必需将它的名字和类型都写出来。这样才能使编译器去检查你重写的属性是与超类中同名同类型的属性相匹配的。
 
-你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供getter和setter即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。
+你可以将一个继承来的只读属性重写为一个读写属性，只需要你在重写版本的属性里提供 getter 和 setter 即可。但是，你不可以将一个继承来的读写属性重写为一个只读属性。
 
-> 注意：如果你在重写属性中提供了setter，那么你也一定要提供getter。如果你不想在重写版本中的getter里修改继承来的属性值，你可以直接返回`super.someProperty`来返回继承来的值。正如下面的`SpeedLimitedCar`的例子所示。
+> 注意：
+>
+如果你在重写属性中提供了 setter，那么你也一定要提供 getter。如果你不想在重写版本中的 getter 里修改继承来的属性值，你可以直接返回`super.someProperty`来返回继承来的值。正如下面的`SpeedLimitedCar`的例子所示。
 
 以下的例子定义了一个新类，叫`SpeedLimitedCar`，它是`Car`的子类。类`SpeedLimitedCar`表示安装了限速装置的车，它的最高速度只能达到40mph。你可以通过重写继承来的`speed`属性来实现这个速度限制：
 
@@ -210,9 +232,11 @@ println("SpeedLimitedCar: \(limitedCar.description())")
 
 #### 重写属性观察器（Property Observer）
 
-你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器]()。
+你可以在属性重写中为一个继承来的属性添加属性观察器。这样一来，当继承来的属性值发生改变时，你就会被通知到，无论那个属性原本是如何实现的。关于属性观察器的更多内容，请看[属性观察器](../chapter2/_10Properties.html#property_observer)。
 
-> 注意：你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供willSet或didSet实现是不恰当。此外还要注意，你不可以同时提供重写的setter和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的setter，那么你在setter中就可以观察到任何值变化了。
+> 注意：
+>
+你不可以为继承来的常量存储型属性或继承来的只读计算型属性添加属性观察器。这些属性的值是不可以被设置的，所以，为它们提供`willSet`或`didSet`实现是不恰当。此外还要注意，你不可以同时提供重写的 setter 和重写的属性观察器。如果你想观察属性值的变化，并且你已经为那个属性提供了定制的 setter，那么你在 setter 中就可以观察到任何值变化了。
 
 下面的例子定义了一个新类叫`AutomaticCar`，它是`Car`的子类。`AutomaticCar`表示自动挡汽车，它可以根据当前的速度自动选择合适的挡位。`AutomaticCar`也提供了定制的`description`方法，可以输出当前挡位。
 
@@ -230,7 +254,7 @@ class AutomaticCar: Car {
 }
 ```
 
-当你设置`AutomaticCar`的`speed`属性，属性的didSet观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：
+当你设置`AutomaticCar`的`speed`属性，属性的`didSet`观察器就会自动地设置`gear`属性，为新的速度选择一个合适的挡位。具体来说就是，属性观察器将新的速度值除以10，然后向下取得最接近的整数值，最后加1来得到档位`gear`的值。例如，速度为10.0时，挡位为1；速度为35.0时，挡位为4：
 
 ```
 let automatic = AutomaticCar()
@@ -239,10 +263,11 @@ println("AutomaticCar: \(automatic.description())")
 // AutomaticCar: 4 wheels; up to 5 passengers; traveling at 35.0 mph in gear 4
 ```
 
+
 ## 防止重写
 
-你可以通过把方法，属性或下标标记为`final`来防止它们被重写，只需要在声明关键字前加上`@final`特性即可。（例如：`@final var`, `@final func`, `@final class func`, 以及 `@final subscript`）
+你可以通过把方法，属性或附属脚本标记为*`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 的，这样的类是不可被继承的，否则会报编译错误。
diff --git a/source/chapter2/14_Initialization.md b/source/chapter2/14_Initialization.md
index e69de29b..36ad697b 100644
--- a/source/chapter2/14_Initialization.md
+++ b/source/chapter2/14_Initialization.md
@@ -0,0 +1,601 @@
+> 翻译：lifedim
+
+> 校对：lifedim
+
+# 构造过程（Initialization）
+
+-----------------
+
+本页包含内容：
+
+- [存储型属性的初始赋值](#setting_initial_values_for_stored_properties)
+- [定制化构造过程](#customizing_initialization)
+- [默认构造器](#default_initializers)
+- [值类型的构造器代理](#initializer_delegation_for_value_types)
+- [类的继承和构造过程](#class_inheritance_and_initialization)
+- [通过闭包和函数来设置属性的默认值](#setting_a_default_property_value_with_a_closure_or_function)
+
+
+构造过程是为了使用某个类、结构体或枚举类型的实例而进行的准备过程。这个过程包含了为实例中的每个属性设置初始值和为其执行必要的准备和初始化任务。
+
+构造过程是通过定义构造器（`Initializers`）来实现的，这些构造器可以看做是用来创建特定类型实例的特殊方法。与 Objective-C 中的构造器不同，Swift 的构造器无需返回值，它们的主要任务是保证新实例在第一次使用前完成正确的初始化。
+
+类实例也可以通过定义析构器（`deinitializer`）在类实例释放之前执行特定的清除工作。想了解更多关于析构器的内容，请参考[析构过程](../chapter2/15_Deinitialization.html)。
+
+
+## 存储型属性的初始赋值
+
+类和结构体在实例创建时，必须为所有存储型属性设置合适的初始值。存储型属性的值不能处于一个未知的状态。
+
+你可以在构造器中为存储型属性赋初值，也可以在定义属性时为其设置默认值。以下章节将详细介绍这两种方法。
+
+>注意：
+>
+当你为存储型属性设置默认值或者在构造器中为其赋值时，它们的值是被直接设置的，不会触发任何属性观测器（`property observers`）。
+
+### 构造器
+
+构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法，以关键字`init`命名。
+
+下面例子中定义了一个用来保存华氏温度的结构体`Fahrenheit`，它拥有一个`Double`类型的存储型属性`temperature`：
+
+    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`设置默认值：
+
+    struct Fahrenheit {
+        var temperature = 32.0
+    }
+
+
+## 定制化构造过程
+
+你可以通过输入参数和可选属性类型来定制构造过程，也可以在构造过程中修改常量属性。这些都将在后面章节中提到。
+
+### 构造参数
+
+你可以在定义构造器时提供构造参数，为其提供定制化构造所需值的类型和名字。构造器参数的功能和语法跟函数和方法参数相同。
+
+下面例子中定义了一个包含摄氏度温度的结构体`Celsius`。它定义了两个不同的构造器：`init(fromFahrenheit:)`和`init(fromKelvin:)`，二者分别通过接受不同刻度表示的温度值来创建新的实例：
+
+	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`类型的构造参数：
+
+	struct Color {
+	    let red = 0.0, green = 0.0, blue = 0.0
+	    init(red: Double, green: Double, blue: Double) {
+	        self.red   = red
+	        self.green = green
+	        self.blue  = blue
+	    }
+	}
+
+每当你创建一个新的`Color`实例，你都需要通过三种颜色的外部参数名来传值，并调用构造器。
+
+    let magenta = Color(red: 1.0, green: 0.0, blue: 1.0)
+
+注意，如果不通过外部参数名字传值，你是没法调用这个构造器的。只要构造器定义了某个外部参数名，你就必须使用它，忽略它将导致编译错误：
+
+	let veryGreen = Color(0.0, 1.0, 0.0)
+	// 报编译时错误，需要外部名称
+
+### 可选属性类型
+
+如果你定制的类型包含一个逻辑上允许取值为空的存储型属性--不管是因为它无法在初始化时赋值，还是因为它可以在之后某个时间点可以赋值为空--你都需要将它定义为可选类型`optional type`。可选类型的属性将自动初始化为空`nil`，表示这个属性是故意在初始化时设置为空的。
+
+下面例子中定义了类`SurveyQuestion`，它包含一个可选字符串属性`response`：
+
+	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`属性现在是常量，我们仍然可以在其类的构造器中修改它的值：
+
+	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.)
+
+
+## 默认构造器
+
+Swift 将为所有属性已提供默认值的且自身没有定义任何构造器的结构体或基类，提供一个默认的构造器。这个默认构造器将简单的创建一个所有属性值都设置为默认值的实例。
+
+下面例子中创建了一个类`ShoppingListItem`，它封装了购物清单中的某一项的属性：名字（`name`）、数量（`quantity`）和购买状态 `purchase state`。
+
+	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`创建新的实例：
+
+	struct Size {
+	    var width = 0.0, height = 0.0
+	}
+	let twoByTwo = Size(width: 2.0, height: 2.0)
+
+
+## 值类型的构造器代理
+
+构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能减少多个构造器间的代码重复。
+
+构造器代理的实现规则和形式在值类型和类类型中有所不同。值类型（结构体和枚举类型）不支持继承，所以构造器代理的过程相对简单，因为它们只能代理任务给本身提供的其它构造器。类则不同，它可以继承自其它类（请参考[继承](../chapter2/13_Inheritance.html)），这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。这些责任将在后续章节[类的继承和构造过程](#class_inheritance_and_initialization)中介绍。
+
+对于值类型，你可以使用`self.init`在自定义的构造器中引用其它的属于相同值类型的构造器。并且你只能在构造器内部调用`self.init`。
+
+注意，如果你为某个值类型定义了一个定制的构造器，你将无法访问到默认构造器（如果是结构体，则无法访问逐一对象构造器）。这个限制可以防止你在为值类型定义了一个更复杂的，完成了重要准备构造器之后，别人还是错误的使用了那个自动生成的构造器。
+
+>注意：
+>
+假如你想通过默认构造器、逐一对象构造器以及你自己定制的构造器为值类型创建实例，我们建议你将自己定制的构造器写到扩展（`extension`）中，而不是跟值类型定义混在一起。想查看更多内容，请查看[扩展](../chapter2/20_Extensions.html)章节。
+
+下面例子将定义一个结构体`Rect`，用来展现几何矩形。这个例子需要两个辅助的结构体`Size`和`Point`，它们各自为其所有的属性提供了初始值`0.0`。
+
+	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`结构体定义中，我们为着三种方式提供了三个自定义的构造器：
+
+	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)`：
+
+	let basicRect = Rect()
+	// basicRect 的原点是 (0.0, 0.0)，尺寸是 (0.0, 0.0)
+
+第二个`Rect`构造器`init(origin:size:)`，在功能上跟结构体在没有自定义构造器时获得的逐一成员构造器是一样的。这个构造器只是简单的将`origin`和`size`的参数值赋给对应的存储型属性：
+
+	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`值赋值到对应的属性中：
+
+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)。
+
+
+## 类的继承和构造过程
+
+类里面的所有存储型属性--包括所有继承自父类的属性--都必须在构造过程中设置初始值。
+
+Swift 提供了两种类型的类构造器来确保所有类实例中存储型属性都能获得初始值，它们分别是指定构造器和便利构造器。
+
+### 指定构造器和便利构造器
+
+指定构造器是类中最主要的构造器。一个指定构造器将初始化类中提供的所有属性，并根据父类链往上调用父类的构造器来实现父类的初始化。
+
+每一个类都必须拥有至少一个指定构造器。在某些情况下，许多类通过继承了父类中的指定构造器而满足了这个条件。具体内容请参考后续章节[自动构造器的继承](#automatic_initializer_inheritance)。
+
+便利构造器是类中比较次要的、辅助型的构造器。你可以定义便利构造器来调用同一个类中的指定构造器，并为其参数提供默认值。你也可以定义便利构造器来创建一个特殊用途或特定输入的实例。
+
+你应当只在必要的时候为类提供便利构造器，比方说某种情况下通过使用便利构造器来快捷调用某个指定构造器，能够节省更多开发时间并让类的构造过程更清、晰明。
+
+
+### 构造器链
+
+为了简化指定构造器和便利构造器之间的调用关系，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)
+
+
+### 两段式构造过程
+
+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`。
+
+
+### 自动构造器的继承
+
+如上所述，子类不会默认继承父类的构造器。但是如果特定条件可以满足，父类构造器是可以被自动继承的。在实践中，这意味着对于许多常见场景你不必重载父类的构造器，并且在尽可能安全的情况下以最小的代价来继承父类的构造器。
+
+假设要为子类中引入的任意新属性提供默认值，请遵守以下2个规则：
+
+#### 规则 1
+
+如果子类没有定义任何指定构造器，它将自动继承所有父类的指定构造器。
+
+#### 规则 2
+
+如果子类提供了所有父类指定构造器的实现--不管是通过规则1继承过来的，还是通过自定义实现的--它将自动继承所有父类的便利构造器。
+
+即使你在子类中添加了更多的便利构造器，这两条规则仍然适用。
+
+>注意：
+>
+子类可以通过部分满足规则2的方式，使用子类便利构造器来实现父类的指定构造器。
+
+### 指定构造器和便利构造器的语法
+
+类的指定构造器的写法跟值类型简单构造器一样：
+
+	init(parameters) {
+	    statements
+	}
+
+便利构造器也采用相同样式的写法，但需要在`init`关键字之前放置`convenience`关键字，并使用空格将它们俩分开：
+
+	convenience init(parameters) {
+	    statements
+	}
+
+### 指定构造器和便利构造器实战
+
+接下来的例子将在实战中展示指定构造器、便利构造器和自动构造器的继承。它定义了包含三个类`Food`、`RecipeIngredient`以及`ShoppingListItem`的类层次结构，并将演示它们的构造器是如何相互作用的。
+
+类层次中的基类是`Food`，它是一个简单的用来封装食物名字的类。`Food`类引入了一个叫做`name`的`String`类型属性，并且提供了两个构造器来创建`Food`实例：
+
+	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`实例：
+
+	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]`来实现：
+
+	let mysteryMeat = Food()
+	// mysteryMeat 的名字是 [Unnamed]
+
+类层级中的第二个类是`Food`的子类`RecipeIngredient`。`RecipeIngredient`类构建了食谱中的一味调味剂。它引入了`Int`类型的数量属性`quantity`（以及从`Food`继承过来的`name`属性），并且定义了两个构造器来创建`RecipeIngredient`实例：
+
+	class RecipeIngredient: Food {
+	    var quantity: Int
+	    init(name: String, quantity: Int) {
+	        self.quantity = quantity
+	        super.init(name: name)
+	    }
+	    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)`相同的参数。尽管`RecipeIngredient`这个构造器是便利构造器，`RecipeIngredient`依然提供了对所有父类指定构造器的实现。因此，`RecipeIngredient`也能自动继承了所有父类的便利构造器。
+
+在这个例子中，`RecipeIngredient`的父类是`Food`，它有一个便利构造器`init()`。这个构造器因此也被`RecipeIngredient`继承。这个继承的`init()`函数版本跟`Food`提供的版本是一样的，除了它是将任务代理给`RecipeIngredient`版本的`init(name: String)`而不是`Food`提供的版本。
+
+所有的这三种构造器都可以用来创建新的`RecipeIngredient`实例：
+
+	let oneMysteryItem = RecipeIngredient()
+	let oneBacon = RecipeIngredient(name: "Bacon")
+	let sixEggs = RecipeIngredient(name: "Eggs", quantity: 6)
+
+类层级中第三个也是最后一个类是`RecipeIngredient`的子类，叫做`ShoppingListItem`。这个类构建了购物单中出现的某一种调味料。
+
+购物单中的每一项总是从`unpurchased`未购买状态开始的。为了展现这一事实，`ShoppingListItem`引入了一个布尔类型的属性`purchased`，它的默认值是`false`。`ShoppingListItem`还添加了一个计算型属性`description`，它提供了关于`ShoppingListItem`实例的一些文字描述：
+
+	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`的新实例：
+
+	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`，并标记为已购买。接下来通过遍历数组每个元素并打印它们的描述值，展示了所有项当前的默认状态都已按照预期完成了赋值。
+
+
+## 通过闭包和函数来设置属性的默认值
+
+如果某个存储型属性的默认值需要特别的定制或准备，你就可以使用闭包或全局函数来为其属性提供定制的默认值。每当某个属性所属的新类型实例创建时，对应的闭包或函数会被调用，而它们的返回值会当做默认值赋值给这个属性。
+
+这种类型的闭包或函数一般会创建一个跟属性类型相同的临时变量，然后修改它的值以满足预期的初始状态，最后将这个临时变量的值作为属性的默认值进行返回。
+
+下面列举了闭包如何提供默认值的代码概要：
+
+	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`数组是通过一个闭包来初始化和组装颜色值的：
+
+	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`这个工具函数来查询。
+
+	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 939b2d12..3b8d3bfb 100644
--- a/source/chapter2/15_Deinitialization.md
+++ b/source/chapter2/15_Deinitialization.md
@@ -1,89 +1,98 @@
-# 析构过程
------------------
+> 翻译：bruce0505
 
-在一个类的实例被释放之前，析构函数被立即调用。用关键字deinit来标示析构函数，类似于初始化函数用init来标示。析构函数只适用于类类型。
+> 校对：fd5788
 
 
+# 析构过程（Deinitialization）
+---------------------------
+
+本页包含内容：
+
+- [析构过程原理](#how_deinitialization_works)
+- [析构函数操作](#deinitializers_in_action)
+
+在一个类的实例被释放之前，析构函数被立即调用。用关键字`deinit`来标示析构函数，类似于初始化函数用`init`来标示。析构函数只适用于类类型。
+
+
 ##析构过程原理
 
-Swift会自动释放不再需要的实例以释放资源。如自动引用计数那一章描述，Swift通过自动引用计数（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动的去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
+Swift 会自动释放不再需要的实例以释放资源。如[自动引用计数](16_Automatic_Reference_Counting.html)那一章描述，Swift 通过_自动引用计数_（ARC）处理实例的内存管理。通常当你的实例被释放时不需要手动地去清理。但是，当使用自己的资源时，你可能需要进行一些额外的清理。例如，如果创建了一个自定义的类来打开一个文件，并写入一些数据，你可能需要在类实例被释放之前关闭该文件。
 
-在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号:
+在类的定义中，每个类最多只能有一个析构函数。析构函数不带任何参数，在写法上不带括号：
 
-    1  deinit {
-    2  	 // 执行析构过程
-	3  }
+    deinit {
+        // 执行析构过程
+	}
 
 析构函数是在实例释放发生前一步被自动调用。不允许主动调用自己的析构函数。子类继承了父类的析构函数，并且在子类析构函数实现的最后，父类的析构函数被自动调用。即使子类没有提供自己的析构函数，父类的析构函数也总是被调用。
 
-因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为(比如查找一个需要被关闭的文件的名称)。
+因为直到实例的析构函数被调用时，实例才会被释放，所以析构函数可以访问所有请求实例的属性，并且根据那些属性可以修改它的行为（比如查找一个需要被关闭的文件的名称）。
 
+
 ##析构函数操作
 
-这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，Bank和Player。Bank结构体管理一个虚拟货币的流通，在这个流通中Bank永远不可能拥有超过10,000的硬币。在这个游戏中有且只能有一个Bank存在，因此Bank由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
+这里是一个析构函数操作的例子。这个例子是一个简单的游戏，定义了两种新类型，`Bank`和`Player`。`Bank`结构体管理一个虚拟货币的流通，在这个流通中`Bank`永远不可能拥有超过 10,000 的硬币。在这个游戏中有且只能有一个`Bank`存在，因此`Bank`由带有静态属性和静态方法的结构体实现，从而存储和管理其当前的状态。
 
-	1  struct Bank {
-    2 	 static var coinsInBank = 10_000
-    3 	 static func vendCoins(var numberOfCoinsToVend: Int) -> Int {
-    4     	numberOfCoinsToVend = min(numberOfCoinsToVend, coinsInBank)
-    5     	coinsInBank -= numberOfCoinsToVend
-    6     	return numberOfCoinsToVend
-    7 	 }
-    8  	 static func receiveCoins(coins: Int) {
-    9    coinsInBank += coins
-    10	 }
-	11  }
+	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，用来处理硬币的分发和收集。
+`Bank`根据它的`coinsInBank`属性来跟踪当前它拥有的硬币数量。银行还提供两个方法——`vendCoins`和`receiveCoins`——用来处理硬币的分发和收集。
 
-vendCoins方法在bank分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，bank返回一个比请求时小的数字(如果没有硬币留在bank中就返回0)。vendCoins方法声明numberOfCoinsToVend为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。vendCoins方法返回一个整型值，表明了提供的硬币的实际数目。
+`vendCoins`方法在 bank 分发硬币之前检查是否有足够的硬币。如果没有足够多的硬币，`Bank`返回一个比请求时小的数字(如果没有硬币留在 bank 中就返回 0)。`vendCoins`方法声明`numberOfCoinsToVend`为一个变量参数，这样就可以在方法体的内部修改数字，而不需要定义一个新的变量。`vendCoins`方法返回一个整型值，表明了提供的硬币的实际数目。
 
-receiveCoins方法只是将bank的硬币存储和接收到的硬币数目相加，再保存回bank。
+`receiveCoins`方法只是将 bank 的硬币存储和接收到的硬币数目相加，再保存回 bank。
 
-Player类描述了游戏中的一个玩家。每一个player在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过player的coinsInPurse属性来体现:
+`Player`类描述了游戏中的一个玩家。每一个 player 在任何时刻都有一定数量的硬币存储在他们的钱包中。这通过 player 的`coinsInPurse`属性来体现：
 
-		1  class Player {
-		2     var coinsInPurse: Int
-		3     init(coins: Int) {
-		4         coinsInPurse = Bank.vendCoins(coins)
-		5     }
-		6     func winCoins(coins: Int) {
-		7         coinsInPurse += Bank.vendCoins(coins)
-		8     }
-		9     deinit {
-		10        Bank.receiveCoins(coinsInPurse)
-		11    }
-		12  }
+		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`实例都由一个指定数目硬币组成的启动额度初始化，这些硬币在 bank 初始化的过程中得到。如果没有足够的硬币可用，`Player`实例可能收到比指定数目少的硬币。
 
-Player类定义了一个winCoins方法，该方法从bank获取一定数量的硬币，并把它们添加到player的钱包。Player类还实现了一个析构函数，这个析构函数在Player实例释放前一步被调用。这里析构函数只是将player的所有硬币都返回给bank:
+`Player`类定义了一个`winCoins`方法，该方法从银行获取一定数量的硬币，并把它们添加到玩家的钱包。`Player`类还实现了一个析构函数，这个析构函数在`Player`实例释放前一步被调用。这里析构函数只是将玩家的所有硬币都返回给银行：
 
-	1  var playerOne: Player? = Player(coins: 100)
-	2  println("A new player has joined the game with \	(playerOne!.coinsInPurse) coins")
-	3  // 输出 "A new player has joined the game with 100 	coins"
-	4  println("There are now \(Bank.coinsInBank) coins left 	in the bank")
-	5  // 输出 "There are now 9900 coins left in the bank"
+	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变量中。这里使用一个可选变量，是因为players可以随时离开游戏。设置为可选使得你可以跟踪当前是否有player在游戏中。
+一个新的`Player`实例随着一个 100 个硬币（如果有）的请求而被创建。这`个Player`实例存储在一个名为`playerOne`的可选`Player`变量中。这里使用一个可选变量，是因为玩家可以随时离开游戏。设置为可选使得你可以跟踪当前是否有玩家在游戏中。
 
-因为playerOne是可选的，所以由一个感叹号(!)来修饰，每当其winCoins方法被调用时，coinsInPurse属性被访问并打印出它的默认硬币数目。
+因为`playerOne`是可选的，所以由一个感叹号（`!`）来修饰，每当其`winCoins`方法被调用时，`coinsInPurse`属性被访问并打印出它的默认硬币数目。
 
-	1  playerOne!.winCoins(2_000)
-	2  println("PlayerOne won 2000 coins & now has \	(playerOne!.coinsInPurse) coins")
-	3  // 输出 "PlayerOne won 2000 coins & now has 2100 coins"
-	4  println("The bank now only has \(Bank.coinsInBank) coins left")
-	5  // 输出 "The bank now only has 7900 coins left"
+	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硬币。
-
-	1  playerOne = nil
-	2  println("PlayerOne has left the game")
-	3  // 输出 "PlayerOne has left the game"
-	4  println("The bank now has \(Bank.coinsInBank) coins")
-	5  // 输出 "The bank now has 10000 coins"
-
-player现在已经离开了游戏。这表明是要将可选的playerOne变量设置为nil，意思是"没有Player实例"。当这种情况发生的时候，playerOne变量对Player实例的引用被破坏了。没有其它属性或者变量引用Player实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到bank。
+这里，player 已经赢得了 2,000 硬币。player 的钱包现在有 2,100 硬币，bank 只剩余 7,900 硬币。
 
+	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`实例，因此为了清空它占用的内存从而释放它。在这发生前一步，其析构函数被自动调用，其硬币被返回到银行。
diff --git a/source/chapter2/16_Automatic_Reference_Counting.md b/source/chapter2/16_Automatic_Reference_Counting.md
index 603fc1f7..3279c616 100644
--- a/source/chapter2/16_Automatic_Reference_Counting.md
+++ b/source/chapter2/16_Automatic_Reference_Counting.md
@@ -1,34 +1,42 @@
+> 翻译：TimothyYe
+
+> 校对：Hawstein
+
 # 自动引用计数
 -----------------
 
 本页包含内容：
 
--   自动引用计数的工作机制
--   自动引用计数实践
--   类实例间的强引用环
--   类实例间的强引用环分解
--   闭包的强引用环
--   闭包的强引用环分解
+-   [自动引用计数的工作机制](#how_arc_works)
+-   [自动引用计数实践](#arc_in_action)
+-   [类实例间的强引用环](#strong_reference_cycles_between_class_instances)
+-   [类实例间的强引用环分解](#resolving_strong_reference_cycles_between_class_instances)
+-   [闭包的强引用环](#strong_reference_cycles_for_closures)
+-   [闭包的强引用环分解](#resolving_strong_reference_cycles_for_closures)
 
-Swift使用自动引用计数(ARC)这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC会在类的实例不再被使用时，自动释放其占用的内存。
+Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。
 
-然而，在少数情况下，ARC为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用ARC来管理你的应用程序的内存。
+然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。
 
-> 注意: 引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
+> 注意:
+>
+引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。
 
+
 ## 自动引用计数的工作机制
 
-当你每次创建一个类的新的实例的时候，ARC会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
+当你每次创建一个类的新的实例的时候，ARC 会分配一大块内存用来储存实例的信息。内存中会包含实例的类型信息，以及这个实例所有相关属性的值。此外，当实例不再被使用时，ARC 释放实例所占用的内存，并让释放的内存能挪作他用。这确保了不再被使用的实例，不会一直占用内存空间。
 
-然而，当ARC收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
+然而，当 ARC 收回和释放了正在被使用中的实例，该实例的属性和方法将不能再被访问和调用。实际上，如果你试图访问这个实例，你的应用程序很可能会崩溃。
 
-为了确保使用中的实例不会被销毁，ARC会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。
+为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。
 
 为了使之成为可能，无论你将实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。
 
+
 ## 自动引用计数实战
 
-下面的例子展示了自动引用计数的工作机制。例子以一个简单的Person类开始，并定义了一个叫name的常量属性：
+下面的例子展示了自动引用计数的工作机制。例子以一个简单的`Person`类开始，并定义了一个叫`name`的常量属性：
 
 		class Person {
     		let name: String
@@ -37,55 +45,56 @@ Swift使用自动引用计数(ARC)这一机制来跟踪和管理你的应用程
         		self.name = name
         		println("\(name) is being initialized")
     		}
-    		
+
 				deinit {
         		println("\(name) is being deinitialized")
     		}
 		}
 
-Person类有一个构造函数，此构造函数为实例的name属性赋值并打印出信息，以表明初始化过程生效。Person类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。
+`Person`类有一个构造函数，此构造函数为实例的`name`属性赋值并打印出信息，以表明初始化过程生效。`Person`类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。
 
-接下来的代码片段定义了三个类型为Person?的变量，用来按照代码片段中的顺序，为新的Person实例建立多个引用。由于这些变量是被定义为可选类型(Person?，而不是Person)，它们的值会被自动初始化为nil，目前还不会引用到Person类的实例。
+接下来的代码片段定义了三个类型为`Person?`的变量，用来按照代码片段中的顺序，为新的`Person`实例建立多个引用。由于这些变量是被定义为可选类型（Person?，而不是Person），它们的值会被自动初始化为`nil`，目前还不会引用到`Person`类的实例。
 
 		var reference1: Person?
 		var reference2: Person?
 		var reference3: Person?
 
-现在你可以创建Person类的新实例，并且将它赋值给三个变量其中的一个：
+现在你可以创建`Person`类的新实例，并且将它赋值给三个变量其中的一个：
 
 		reference1 = Person(name: "John Appleseed")
 		// prints "John Appleseed is being initialized”
 
-应当注意到当你调用Person类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。
+应当注意到当你调用`Person`类的构造函数的时候，"John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。
 
-由于Person类的新实例被赋值给了reference1变量，所以reference1到Person类的新实例之间建立了一个强引用。正是因为这个强引用，ARC会保证Person实例被保持在内存中不被销毁。
+由于`Person`类的新实例被赋值给了`reference1`变量，所以`reference1`到`Person`类的新实例之间建立了一个强引用。正是因为这个强引用，ARC 会保证`Person`实例被保持在内存中不被销毁。
 
-如果你将同样的Person实例也赋值给其他两个变量，该实例又会多出两个强引用：
+如果你将同样的`Person`实例也赋值给其他两个变量，该实例又会多出两个强引用：
 
 		reference2 = reference1
 		reference3 = reference1
 
-现在这个Person实例已经有三个强引用了。
+现在这个`Person`实例已经有三个强引用了。
 
-如果你通过给两个变量赋值nil的方式断开两个强引用(包括最先的那个强引用），只留下一个强引用，Person实例不会被销毁：
+如果你通过给两个变量赋值`nil`的方式断开两个强引用（）包括最先的那个强引用），只留下一个强引用，`Person`实例不会被销毁：
 
     reference2 = reference1
     reference3 = reference1
 
-ARC会在第三个，也即最后一个强引用被断开的时候，销毁Person实例，这也意味着你不再使用这个Person实例：
+ARC 会在第三个，也即最后一个强引用被断开的时候，销毁`Person`实例，这也意味着你不再使用这个`Person`实例：
 
     reference3 = nil
     // prints "John Appleseed is being deinitialized"
-    
+
+
 ## 类实例之间的循环强引用
 
-在上面的例子中，ARC会跟踪你所新创建的Person实例的引用数量，并且会在Person实例不再被需要时销毁它。
+在上面的例子中，ARC 会跟踪你所新创建的`Person`实例的引用数量，并且会在`Person`实例不再被需要时销毁它。
 
 然而，我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。
 
-你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在[解决类实例之间的循环强引用](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/chapter2/16_Automatic_Reference_Counting.html#1)中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。
+你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在[解决类实例之间的循环强引用](#1)中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。
 
-下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：Person和Apartment，用来建模公寓和它其中的居民:
+下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：`Person`和`Apartment`，用来建模公寓和它其中的居民:
 
     class Person {
         let name: String
@@ -93,7 +102,7 @@ ARC会在第三个，也即最后一个强引用被断开的时候，销毁Perso
         var apartment: Apartment?
         deinit { println("\(name) is being deinitialized") }
     }
- 
+
     class Apartment {
         let number: Int
         init(number: Int) { self.number = number }
@@ -101,69 +110,73 @@ ARC会在第三个，也即最后一个强引用被断开的时候，销毁Perso
         deinit { println("Apartment #\(number) is being deinitialized") }
     }
 
-每一个Person实例有一个类型为String，名字为name的属性，并有一个可选的初始化为nil的apartment属性。apartment属性是可选的，因为一个人并不总是拥有公寓。
+每一个`Person`实例有一个类型为`String`，名字为`name`的属性，并有一个可选的初始化为`nil`的`apartment`属性。`apartment`属性是可选的，因为一个人并不总是拥有公寓。
 
-类似的，每个Apartment实例有一个叫number，类型为Int的属性，并有一个可选的初始化为nil的tenant属性。tenant属性是可选的，因为一栋公寓并不总是有居民。
+类似的，每个`Apartment`实例有一个叫`number`，类型为`Int`的属性，并有一个可选的初始化为`nil`的`tenant`属性。`tenant`属性是可选的，因为一栋公寓并不总是有居民。
 
-这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓Person和Apartment的实例是否像预期的那样被销毁。
+这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓`Person`和`Apartment`的实例是否像预期的那样被销毁。
 
-接下来的代码片段定义了两个可选类型的变量john和number73,并分别被设定为下面的Apartment和Person的实例。这两个变量都被初始化为nil，并为可选的：
+接下来的代码片段定义了两个可选类型的变量`john`和`number73`,并分别被设定为下面的`Apartment`和`Person`的实例。这两个变量都被初始化为`nil`，并为可选的：
 
     var john: Person?
     var number73: Apartment?
 
-现在你可以创建特定的Person和Apartment实例并将类实例赋值给john和number73变量：
+现在你可以创建特定的`Person`和`Apartment`实例并将类实例赋值给`john`和`number73`变量：
 
     john = Person(name: "John Appleseed")
     number73 = Apartment(number: 73)
-    
-在两个实例被创建和赋值后，下图表面了强引用的关系。变量john现在有一个指向Person实例的强引用，而变量number73有一个指向Apartment实例的强引用：
+
+在两个实例被创建和赋值后，下图表面了强引用的关系。变量`john`现在有一个指向`Person`实例的强引用，而变量`number73`有一个指向`Apartment`实例的强引用：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle01_2x.png)
 
-现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量john和number73中的实例，这样实例的属性才能被赋值：
+现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量`john`和`number73`中的实例，这样实例的属性才能被赋值：
 
     john!.apartment = number73
     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 销毁：
 
     john = nil
     number73 = nil
-    
-注意，当你把这两个变量设为nil时，没有任何一个析构函数被调用。强引用循环阻止了Person和Apartment类实例的销毁，并在你的应用程序中造成了内存泄漏。
 
-在你将john和number73赋值为nil后，强引用关系如下图：
+注意，当你把这两个变量设为`nil`时，没有任何一个析构函数被调用。强引用循环阻止了`Person`和`Apartment`类实例的销毁，并在你的应用程序中造成了内存泄漏。
+
+在你将`john`和`number73`赋值为`nil`后，强引用关系如下图：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle03_2x.png)
 
-Person和Apartment实例之间的强引用关系保留了下来并且不会被断开。
+`Person`和`Apartment`实例之间的强引用关系保留了下来并且不会被断开。
 
-##解决实例之间的循环强引用
+
+##解决实例之间的循环强引用
 
-Swift提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用(weak reference)和无主引用(unowned reference)。
+Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和无主引用（unowned reference）。
 
 弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。
 
-对于生命周期中会变为nil的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为nil的实例，使用无主引用。
+对于生命周期中会变为`nil`的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为`nil`的实例，使用无主引用。
 
-## 弱引用
 
-弱引用不会牢牢保持住引用的实例，并且不会阻止ARC销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。
+### 弱引用
 
-在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](http://numbbbbb.github.io/the-swift-programming-language-in-chinese/chapter2/16_Automatic_Reference_Counting.html#2)中有描述。在上面Apartment的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
+弱引用不会牢牢保持住引用的实例，并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上`weak`关键字表明这是一个弱引用。
 
-> 注意: 弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。
+在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在[无主引用](#2)中有描述。在上面`Apartment`的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。
 
-因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在Swift语言中推荐的用来表示可能没有值的类型。
+> 注意:
+>
+弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。
 
-因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC会在引用的实例被销毁后自动将其赋值为nil。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。
+因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。
 
-下面的例子跟上面Person和Apartment的例子一致，但是有一个重要的区别。这一次，Apartment的tenant属性被声明为弱引用：
+因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为`nil`。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。
+
+下面的例子跟上面`Person`和`Apartment`的例子一致，但是有一个重要的区别。这一次，`Apartment`的`tenant`属性被声明为弱引用：
 
     class Person {
         let name: String
@@ -171,66 +184,67 @@ Swift提供了两种办法用来解决你在使用类的属性时所遇到的循
         var apartment: Apartment?
         deinit { println("\(name) is being deinitialized") }
     }
- 
+
     class Apartment {
         let number: Int
         init(number: Int) { self.number = number }
         weak var tenant: Person?
         deinit { println("Apartment #\(number) is being deinitialized") }
     }
-    
-然后跟之前一样，建立两个变量(john和number73)之间的强引用，并关联两个实例：
+
+然后跟之前一样，建立两个变量（john和number73）之间的强引用，并关联两个实例：
 
     var john: Person?
     var number73: Apartment?
- 
+
     john = Person(name: "John Appleseed")
     number73 = Apartment(number: 73)
- 
+
     john!.apartment = number73
     number73!.tenant = john
-    
+
 现在，两个关联在一起的实例的引用关系如下图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference01_2x.png)
 
-Person实例依然保持对Apartment实例的强引用，但是Apartment实例只是对Person实例的弱引用。这意味着当你断开john变量所保持的强引用时，再也没有指向Person实例的强引用了：
+`Person`实例依然保持对`Apartment`实例的强引用，但是`Apartment`实例只是对`Person`实例的弱引用。这意味着当你断开`john`变量所保持的强引用时，再也没有指向`Person`实例的强引用了：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference02_2x.png)
 
-由于再也没有指向Person实例的强引用，该实例会被销毁：
+由于再也没有指向`Person`实例的强引用，该实例会被销毁：
 
     john = nil
     // prints "John Appleseed is being deinitialized"
-    
-唯一剩下的指向Apartment实例的强引用来自于变量number73。如果你断开这个强引用，再也没有指向Apartment实例的强引用了：
+
+唯一剩下的指向`Apartment`实例的强引用来自于变量`number73`。如果你断开这个强引用，再也没有指向`Apartment`实例的强引用了：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference03_2x.png)
 
-由于再也没有指向Apartment实例的强引用，该实例也会被销毁：
+由于再也没有指向`Apartment`实例的强引用，该实例也会被销毁：
 
     number73 = nil
     // prints "Apartment #73 is being deinitialized"
-    
-上面的两段代码展示了变量john和number73在被赋值为nil后，Person实例和Apartment实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
 
-##无主引用
+上面的两段代码展示了变量`john`和`number73`在被赋值为`nil`后，`Person`实例和`Apartment`实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。
 
-和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型(non-optional type)。你可以在声明属性或者变量时，在前面加上关键字unowned表示这是一个无主引用。
+###无主引用
 
-由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过ARC无法在实例被销毁后将无主引用设为nil，因为非可选类型的变量不允许被赋值为nil。
+和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型（non-optional type）。你可以在声明属性或者变量时，在前面加上关键字`unowned`表示这是一个无主引用。
 
-> 注意: 如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。
+由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为`nil`，因为非可选类型的变量不允许被赋值为`nil`。
+
+> 注意:
+>如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。
 
 > 还需要注意的是如果你试图访问实例已经被销毁的无主引用，程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。
 
-下面的例子定义了两个类，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实例与之关联。
+此外，只能通过将一个`number`值和`customer`实例传递给`CreditCard`构造函数的方式来创建`CreditCard`实例。这样可以确保当创建`CreditCard`实例时总是有一个`customer`实例与之关联。
 
-由于信用卡总是关联着一个客户，因此将customer属性定义为无主引用，用以避免循环强引用：
+由于信用卡总是关联着一个客户，因此将`customer`属性定义为无主引用，用以避免循环强引用：
 
     class Customer {
         let name: String
@@ -240,7 +254,7 @@ Customer和CreditCard之间的关系与前面弱引用例子中Apartment和Perso
         }
         deinit { println("\(name) is being deinitialized") }
     }
-    
+
     class CreditCard {
         let number: Int
         unowned let customer: Customer
@@ -251,46 +265,47 @@ Customer和CreditCard之间的关系与前面弱引用例子中Apartment和Perso
         deinit { println("Card #\(number) is being deinitialized") }
     }
 
-下面的代码片段定义了一个叫john的可选类型Customer变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为nil。
+下面的代码片段定义了一个叫`john`的可选类型`Customer`变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为`nil`。
 
     var john: Customer?
-    
-现在你可以创建Customer类的实例，用它初始化CreditCard实例，并将新创建的CreditCard实例赋值为客户的card属性。
+
+现在你可以创建`Customer`类的实例，用它初始化`CreditCard`实例，并将新创建的`CreditCard`实例赋值为客户的`card`属性。
 
     john = Customer(name: "John Appleseed")
     john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
-    
+
 在你关联两个实例后，他们的引用关系如下图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/unownedReference01_2x.png)
 
-Customer实例持有对CreditCard实例的强引用，而CreditCard实例持有对Customer实例的无主引用。
+`Customer`实例持有对`CreditCard`实例的强引用，而`CreditCard`实例持有对`Customer`实例的无主引用。
 
-由于customer的无主引用，当你断开john变量持有的强引用时，再也没有指向Customer实例的强引用了：
+由于`customer`的无主引用，当你断开`john`变量持有的强引用时，再也没有指向`Customer`实例的强引用了：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/unownedReference02_2x.png)
 
-由于再也没有指向Customer实例的强引用，该实例被销毁了。其后，再也没有指向CreditCard实例的强引用，该实例也随之被销毁了：
+由于再也没有指向`Customer`实例的强引用，该实例被销毁了。其后，再也没有指向`CreditCard`实例的强引用，该实例也随之被销毁了：
 
     john = nil
     // prints "John Appleseed is being deinitialized"
     // prints "Card #1234567890123456 is being deinitialized"
-    
-最后的代码展示了在john变量被设为nil后Customer实例和CreditCard实例的构造函数都打印出了“销毁”的信息。
 
-##无主引用以及显式展开的可选属性
+最后的代码展示了在`john`变量被设为`nil`后`Customer`实例和`CreditCard`实例的构造函数都打印出了“销毁”的信息。
+
+
+###无主引用以及显式展开的可选属性
 
 上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。
 
-Person和Apartment的例子展示了两个属性的值都允许为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`属性：
 
     class Country {
         let name: String
@@ -300,7 +315,7 @@ Customer和CreditCard的例子展示了一个属性的值允许为nil，而另
             self.capitalCity = City(name: capitalName, country: self)
         }
     }
- 
+
     class City {
         let name: String
         unowned let country: Country
@@ -309,34 +324,35 @@ Customer和CreditCard的例子展示了一个属性的值允许为nil，而另
             self.country = country
         }
     }
-    
-为了建立两个类的依赖关系，City的构造函数有一个Country实例的参数，并且将实例保存为country属性。
 
-Country的构造函数调用了City的构造函数。然而，只有Country的实例完全初始化完后，Country的构造函数才能把self传给City的构造函数。([在两阶段构造函数中有具体描述](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-XID_288))
+为了建立两个类的依赖关系，`City`的构造函数有一个`Country`实例的参数，并且将实例保存为`country`属性。
 
-为了满足这种需求，通过在类型结尾处加上感叹号(City!)的方式，将Country的capitalCity属性声明为显示展开的可选类型属性。这表示像其他可选类型一样，capitalCity属性的默认值为nil，但是不需要展开他的值就能访问它。([在显示展开的可选类型中有描述](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_436))
+`Country`的构造函数调用了`City`的构造函数。然而，只有`Country`的实例完全初始化完后，`Country`的构造函数才能把`self`传给`City`的构造函数。（[在两步构造函数中有具体描述](14_Initialization.html)）
 
-由于capitalCity默认值为nil，一旦Country的实例在构造函数中给name属性赋值后，整个初始化过程就完成了。这代表一旦name属性被后，Country的构造函数就能引用并传递显式的self。Country的构造函数在赋值capitalCity时，就能将self作为参数传递给City的构造函数。
+为了满足这种需求，通过在类型结尾处加上感叹号（City!）的方式，将`Country`的`capitalCity`属性声明为显示展开的可选类型属性。这表示像其他可选类型一样，`capitalCity`属性的默认值为`nil`，但是不需要展开他的值就能访问它。（[在显示展开的可选类型中有描述](01_The_Basics.html)）
 
-以上的意义在于你可以通过一条语句同时创建Country和City的实例，而不产生循环强引用，并且capitalCity的属性能被直接访问，而不需要通过感叹号来展开它的可选值：
+由于`capitalCity`默认值为`nil`，一旦`Country`的实例在构造函数中给`name`属性赋值后，整个初始化过程就完成了。这代表一旦`name`属性被后，`Country`的构造函数就能引用并传递显式的`self`。`Country`的构造函数在赋值`capitalCity`时，就能将`self`作为参数传递给`City`的构造函数。
+
+以上的意义在于你可以通过一条语句同时创建`Country`和`City`的实例，而不产生循环强引用，并且`capitalCity`的属性能被直接访问，而不需要通过感叹号来展开它的可选值：
 
     var country = Country(name: "Canada", capitalName: "Ottawa")
     println("\(country.name)'s capital city is called \(country.capitalCity.name)")
     // prints "Canada's capital city is called Ottawa"
-    
-在上面的例子中，使用显示展开可选值的意义在于满足了两个类构造函数的需求。capitalCity属性在初始化完成后，能作为非可选值使用同事还避免了循环强引用。
 
+在上面的例子中，使用显示展开可选值的意义在于满足了两个类构造函数的需求。`capitalCity`属性在初始化完成后，能作为非可选值使用同事还避免了循环强引用。
+
+
 ##闭包引起的循环强引用
 
 前面我们看到了循环强引用环是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破循环强引用。
 
-循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如self.someProperty，或者闭包中调用了实例的某个方法，例如self.someMethod。这两种情况都导致了闭包 “捕获" self，从而产生了循环强引用。
+循环强引用还会发生在当你将一个闭包赋值给类实例的某个属性，并且这个闭包体中又使用了实例。这个闭包体中可能访问了实例的某个属性，例如`self.someProperty`，或者闭包中调用了实例的某个方法，例如`self.someMethod`。这两种情况都导致了闭包 “捕获" `self`，从而产生了循环强引用。
 
 循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你也把一个引用赋值给了这个闭包。实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。
 
-Swift提供了一种优雅的方法来解决这个问题，称之为闭包占用列表(closuer capture list)。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。
+Swift 提供了一种优雅的方法来解决这个问题，称之为闭包占用列表（closuer capture list）。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。
 
-下面的例子为你展示了当一个闭包引用了self后是如何产生一个循环强引用的。例子中定义了一个叫HTMLElement的类，用一种简单的模型表示HTML中的一个单独的元素：
+下面的例子为你展示了当一个闭包引用了`self`后是如何产生一个循环强引用的。例子中定义了一个叫`HTMLElement`的类，用一种简单的模型表示 HTML 中的一个单独的元素：
 
     class HTMLElement {
 
@@ -362,49 +378,57 @@ Swift提供了一种优雅的方法来解决这个问题，称之为闭包占用
 
     }
 
-HTMLElement类定义了一个name属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。HTMLElement还定义了一个可选属性text，用来设置和展现HTML元素的文本。
+`HTMLElement`类定义了一个`name`属性来表示这个元素的名称，例如代表段落的"p"，或者代表换行的"br"。`HTMLElement`还定义了一个可选属性`text`，用来设置和展现 HTML 元素的文本。
 
-除了上面的两个属性，HTMLElement还定义了一个lazy属性asHTML。这个属性引用了一个闭包，将name和text组合成HTML字符串片段。该属性是() -> String类型，或者可以理解为“一个没有参数，返回String的函数”。
+除了上面的两个属性，`HTMLElement`还定义了一个`lazy`属性`asHTML`。这个属性引用了一个闭包，将`name`和`text`组合成 HTML 字符串片段。该属性是`() -> String`类型，或者可以理解为“一个没有参数，返回`String`的函数”。
 
-默认情况下，闭包赋值给了asHTML属性，这个闭包返回一个代表HTML标签的字符串。如果text值存在，该标签就包含可选值text；如果text不存在，该标签就不包含文本。对于段落元素，根据text是"some text"还是nil，闭包会返回"`
          some text
          `"或者"`
          `"。
+默认情况下，闭包赋值给了`asHTML`属性，这个闭包返回一个代表 HTML 标签的字符串。如果`text`值存在，该标签就包含可选值`text`；如果`text`不存在，该标签就不包含文本。对于段落元素，根据`text`是"some text"还是`nil`，闭包会返回"`
          some text
          `"或者"`
          `"。
 
-可以像实例方法那样去命名、使用asHTML属性。然而，由于asHTML是闭包而不是实例方法，如果你想改变特定元素的HTML处理的话，可以用自定义的闭包来取代默认值。
+可以像实例方法那样去命名、使用`asHTML`属性。然而，由于`asHTML`是闭包而不是实例方法，如果你想改变特定元素的 HTML 处理的话，可以用自定义的闭包来取代默认值。
 
-> 注意: asHTML声明为lazy属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用asHTML。也就是说，在默认的闭包中可以使用self，因为只有当初始化完成以及self确实存在后，才能访问lazy属性。
+> 注意:
+>
+`asHTML`声明为`lazy`属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用`asHTML`。也就是说，在默认的闭包中可以使用`self`，因为只有当初始化完成以及`self`确实存在后，才能访问`lazy`属性。
 
-HTMLElement类只提供一个构造函数，通过name和text(如果有的话)参数来初始化一个元素。该类也定义了一个析构函数，当HTMLElement实例被销毁时，打印一条消息。
+`HTMLElement`类只提供一个构造函数，通过`name`和`text`（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当`HTMLElement`实例被销毁时，打印一条消息。
 
-下面的代码展示了如何用HTMLElement类创建实例并打印消息。
+下面的代码展示了如何用`HTMLElement`类创建实例并打印消息。
 
     var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
     println(paragraph!.asHTML())
     // prints"hello, world"
-    
->注意: 上面的paragraph变量定义为可选HTMLElement，因此我们可以赋值nil给它来演示循环强引用。 
 
-不幸的是，上面写的HTMLElement类产生了类实例和asHTML默认值的闭包之间的循环强引用。循环强引用如下图所示：
+>注意:
+>
+上面的`paragraph`变量定义为`可选HTMLElement`，因此我们可以赋值`nil`给它来演示循环强引用。
+
+不幸的是，上面写的`HTMLElement`类产生了类实例和`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实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包占有值的信息，请参考[Capturing Values](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Closures.html#//apple_ref/doc/uid/TP40014097-CH11-XID_129)）。
+实例的`asHTML`属性持有闭包的强引用。但是，闭包在其闭包体内使用了`self`（引用了`self.name`和`self.text`），因此闭包占有了`self`，这意味着闭包又反过来持有了`HTMLElement`实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包占有值的信息，请参考[值捕获](07_Closures.html)）。
 
->注意: 虽然闭包多次使用了self，它只占有HTMLElement实例的一个强引用。
+>注意:
+>
+虽然闭包多次使用了`self`，它只占有`HTMLElement`实例的一个强引用。
 
-如果设置paragraph变量为nil，打破它持有的HTMLElement实例的强引用，HTMLElement实例和它的闭包都不会被销毁，也是因为循环强引用：
+如果设置`paragraph`变量为`nil`，打破它持有的`HTMLElement`实例的强引用，`HTMLElement`实例和它的闭包都不会被销毁，也是因为循环强引用：
 
     paragraph = nil
 
-注意HTMLElementdeinitializer中的消息并没有别打印，证明了HTMLElement实例并没有被销毁。
+注意`HTMLElementdeinitializer`中的消息并没有别打印，证明了`HTMLElement`实例并没有被销毁。
 
 ##解决闭包引起的循环强引用
 
 在定义闭包时同时定义占有列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。占有列表定义了闭包体内占有一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个占有的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。
 
->注意: 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`或`someInstance`）成对组成。每一对都在花括号中，通过逗号分开。
 
 占有列表放置在闭包参数列表和返回类型之前：
 
@@ -412,29 +436,31 @@ HTMLElement类只提供一个构造函数，通过name和text(如果有的话)
         [unowned self] (index: Int, stringToProcess: String) -> String in
         // closure body goes here
     }
-    
-如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以占有列表放在闭包开始的地方，跟着是关键字in：
+
+如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以占有列表放在闭包开始的地方，跟着是关键字`in`：
 
     @lazy var someClosure: () -> String = {
         [unowned self] in
         // closure body goes here
     }
 
-##弱引用和无主引用
+###弱引用和无主引用
 
 当闭包和占有的实例总是互相引用时并且总是同时销毁时，将闭包内的占有定义为无主引用。
 
-相反的，当占有引用有时可能会是nil时，将闭包内的占有定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为nil。这使我们可以在闭包内检查他们是否存在。
+相反的，当占有引用有时可能会是`nil`时，将闭包内的占有定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为`nil`。这使我们可以在闭包内检查他们是否存在。
 
->注意: 如果占有的引用绝对不会置为nil，应该用无主引用，而不是弱引用。
+>注意:
+>
+如果占有的引用绝对不会置为`nil`，应该用无主引用，而不是弱引用。
 
-前面的HTMLElement例子中，无主引用是正确的解决循环强引用的方法。这样这样编写HTMLElement类来避免循环强引用：
+前面的`HTMLElement`例子中，无主引用是正确的解决循环强引用的方法。这样这样编写`HTMLElement`类来避免循环强引用：
 
     class HTMLElement {
-    
+
         let name: String
         let text: String?
-    
+
         @lazy var asHTML: () -> String = {
             [unowned self] in
             if let text = self.text {
@@ -443,31 +469,31 @@ HTMLElement类只提供一个构造函数，通过name和text(如果有的话)
                 return "<\(self.name) />"
             }
         }
-    
+
         init(name: String, text: String? = nil) {
             self.name = name
             self.text = text
         }
-    
+
         deinit {
             println("\(name) is being deinitialized")
         }
-    
+
     }
 
-上面的HTMLElement实现和之前的实现一致，只是在asHTML闭包中多了一个占有列表。这里，占有列表是[unowned self]，表示“用无主引用而不是强引用来占有self”。
+上面的`HTMLElement`实现和之前的实现一致，只是在`asHTML`闭包中多了一个占有列表。这里，占有列表是`[unowned self]`，表示“用无主引用而不是强引用来占有`self`”。
 
-和之前一样，我们可以创建并打印HTMLElement实例：
+和之前一样，我们可以创建并打印`HTMLElement`实例：
 
     var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
     println(paragraph!.asHTML())
     // prints "
          hello, world
          "
-    
+
 使用占有列表后引用关系如下图所示：
 
 ![](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle02_2x.png)
 
-这一次，闭包以无主引用的形式占有self，并不会持有HTMLElement实例的强引用。如果将paragraph赋值为nil，HTMLElement实例将会被销毁，并能看到它的析构函数打印出的消息。
+这一次，闭包以无主引用的形式占有`self`，并不会持有`HTMLElement`实例的强引用。如果将`paragraph`赋值为`nil`，`HTMLElement`实例将会被销毁，并能看到它的析构函数打印出的消息。
 
     paragraph = nil
     // prints "p is being deinitialized"
diff --git a/source/chapter2/17_Optional_Chaining.md b/source/chapter2/17_Optional_Chaining.md
index d3cd61d3..351d10f8 100644
--- a/source/chapter2/17_Optional_Chaining.md
+++ b/source/chapter2/17_Optional_Chaining.md
@@ -1,45 +1,60 @@
+> 翻译：Jasonbroker
+
+> 校对：numbbbbb
+
+
 # Optional Chaining
 -----------------
 
+本页包含内容：
+
+- [可选链可替代强制解析](#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 Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的自判断性体现于请求或调用的目标当前可能为空（`nil`）。如果自判断的目标有值，那么调用就会成功；相反，如果选择的目标为空（`nil`），则这种调用将返回空（`nil`）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（`nil`）将导致整个链失效。
 
-> 笔记：
-`Swift`的自判断链和Objective-C中的消息为空有些相像，但是`Swift`可以使用在任意类型中，并且失败与否可以被检测到。
+> 注意：
+Swift 的自判断链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。
 
+
 ## 可选链可替代强制解析
 
-通过在想调用的属性、方法、或子脚本的自判断值（`optional value`）（非空）后面放一个问号，可以定义一个可选链。这一点很像在自判断值后面放一个声明符号来强制拆得其封包内的值。他们的主要的区别在于当自判断值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。
+通过在想调用的属性、方法、或子脚本的可选值（`optional value`）（非空）后面放一个问号，可以定义一个可选链。这一点很像在可选值后面放一个声明符号来强制拆得其封包内的值。他们的主要的区别在于当可选值为空时可选链即刻失败，然而一般的强制解析将会引发运行时错误。
 
-为了反映可选链可以调用空（`nil`），不论你调用的属性、方法、子脚本等返回的值是不是自判断值，它的返回结果都是一个自判断值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。
+为了反映可选链可以调用空（`nil`），不论你调用的属性、方法、子脚本等返回的值是不是可选值，它的返回结果都是一个可选值。你可以利用这个返回值来检测你的可选链是否调用成功，有返回值即成功，返回nil则失败。
 
-调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个自判断值，当可选链调用成功时，一个应该返回`Int`的属性将会返回`Int？`。
+调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回`Int`的属性将会返回`Int?`。
 
 下面几段代码将解释可选链和强制解析的不同。
 
 首先定义两个类`Person`和`Residence`。
 
 	class Person {
-    var residence: Residence?
+        var residence: Residence?
 	}
 
 	class Residence {
-    var numberOfRooms = 1
+        var numberOfRooms = 1
 	}
 
-`Residence`具有一个`Int`类型的`numberOfRooms`，其值为1。`Person`具有一个自判断`residence`属性，它的类型是`Residence？`。
+`Residence`具有一个`Int`类型的`numberOfRooms`，其值为 1。`Person`具有一个自判断`residence`属性，它的类型是`Residence？`。
 
-如果你创建一个新的Person实例，它的residence属性由于是被定义为自判断型的，此属性将默认初始化为空：
+如果你创建一个新的`Person`实例，它的`residence`属性由于是被定义为自判断型的，此属性将默认初始化为空：
 
 	let john = Person()
 
-如果你想使用声明符！强制解析获得这个人`residence`属性`numberOfRooms`属性值，将会引发运行时错误，因为这时没有可以供解析的`residence`值。
+如果你想使用感叹号（`!`）强制解析获得这个人`residence`属性`numberOfRooms`属性值，将会引发运行时错误，因为这时没有可以供解析的`residence`值。
 
 	let roomCount = john.residence!.numberOfRooms
-	// this triggers a runtime error”
 	//将导致运行时错误
 当`john.residence`不是`nil`时，会运行通过，且会将`roomCount` 设置为一个`int`类型的合理值。然而，如上所述，当`residence`为空时，这个代码将会导致运行时错误。
 
-可选链提供了一种另一种获得numberOfRooms的方法。利用可选链，使用问号来代替原来`！`的位置：
+可选链提供了一种另一种获得`numberOfRooms`的方法。利用可选链，使用问号来代替原来`!`的位置：
 
 	if let roomCount = john.residence?.numberOfRooms {
     	println("John's residence has \(roomCount) room(s).")
@@ -49,26 +64,26 @@
 	// 打印 "Unable to retrieve the number of rooms.
 
 
-这告诉Swift来链接自判断`residence？`属性，如果`residence`存在则取回`numberOfRooms`的值。
+这告诉 Swift 来链接自判断`residence?`属性，如果`residence`存在则取回`numberOfRooms`的值。
 
-因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int？`类型值，或者称作“自判断`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出先无法访问`numberOfRooms`的情况。
+因为这种尝试获得`numberOfRooms`的操作有可能失败，可选链会返回`Int?`类型值，或者称作“自判断`Int`”。当`residence`是空的时候（上例），选择`Int`将会为空，因此会出先无法访问`numberOfRooms`的情况。
 
-要注意的是，即使numberOfRooms是非自判断`Int`（`Int？`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int？`而不是`Int`。
+要注意的是，即使numberOfRooms是非自判断`Int`（`Int?`）时这一点也成立。只要是通过可选链的请求就意味着最后`numberOfRooms`总是返回一个`Int?`而不是`Int`。
 
 你可以自己定义一个`Residence`实例给`john.residence`，这样它就不再为空了：
 
 	john.residence = Residence()
 
-`john.residence` 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得`numberOfRoooms`，它将返回一个包含默认值1的`Int？`：
+`john.residence` 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得`numberOfRoooms`，它将返回一个包含默认值 1 的`Int?`：
 
 	if let roomCount = john.residence?.numberOfRooms {
-	println("John's residence has \(roomCount) room(s).")
+	    println("John's residence has \(roomCount) room(s).")
 	} else {
 	    println("Unable to retrieve the number of rooms.")
 	}
 	// 打印 "John's residence has 1 room(s)"。
 
-
+
 ##为可选链定义模型类
 
 你可以使用可选链来多层调用属性，方法，和子脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。
@@ -78,7 +93,7 @@
 `Person`类定义与之前相同。
 
 	class Person {
-	var residence: Residence?
+	    var residence: Residence?
 	}
 
 `Residence`类比之前复杂些。这次，它定义了一个变量 `rooms`，它被初始化为一个`Room[]`类型的空数组：
@@ -103,7 +118,7 @@
 
 `Residence`中也提供了一个`printNumberOfRooms`的方法，即简单的打印房间个数。
 
-最后，`Residence`定义了一个自判断属性叫`address`（`address？`）。`Address`类的属性将在后面定义。
+最后，`Residence`定义了一个自判断属性叫`address`（`address?`）。`Address`类的属性将在后面定义。
 用于`rooms`数组的`Room`类是一个很简单的类，它只有一个`name`属性和一个设定`room`名的初始化器。
 
 	class Room {
@@ -112,7 +127,7 @@
 	}
 
 
-这个模型中的最终类叫做`Address`。它有三个自判断属性他们额类型是`String？`。前面两个自判断属性`buildingName`和 `buildingNumber`作为地址的一部分，是定义某个建筑物的两种方式。第三个属性`street`，用于命名地址的街道名：
+这个模型中的最终类叫做`Address`。它有三个自判断属性他们额类型是`String?`。前面两个自判断属性`buildingName`和 `buildingNumber`作为地址的一部分，是定义某个建筑物的两种方式。第三个属性`street`，用于命名地址的街道名：
 
 	class Address {
 	    var buildingName: String?
@@ -129,11 +144,12 @@
 	    }
 	}
 
-`Address`类还提供了一个`buildingIdentifier`的方法，它的返回值类型为`String？`。这个方法检查`buildingName`和`buildingNumber`的属性，如果`buildingName`有值则将其返回，或者如果`buildingNumber`有值则将其返回，再或如果没有一个属性有值，返回空。
+`Address`类还提供了一个`buildingIdentifier`的方法，它的返回值类型为`String?`。这个方法检查`buildingName`和`buildingNumber`的属性，如果`buildingName`有值则将其返回，或者如果`buildingNumber`有值则将其返回，再或如果没有一个属性有值，返回空。
 
+
 ##通过可选链调用属性
 
-正如上面“ [可选链可替代强制解析]()”中所述，你可以利用可选链的自判断值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。
+正如上面“ [可选链可替代强制解析](#optional_chaining_as_an_alternative_to_forced_unwrapping)”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。
 
 使用上述定义的类来创建一个人实例，并再次尝试后去它的`numberOfRooms`属性：
 
@@ -147,11 +163,12 @@
 
 由于`john.residence`是空，所以这个可选链和之前一样失败了，但是没有运行时错误。
 
+
 ##通过可选链调用方法
 
-你可以使用可选链的来调用自判断值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。
+你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。
 
-Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法如下：
+`Residence`的`printNumberOfRooms`方法会打印`numberOfRooms`的当前值。方法如下：
 
 	func printNumberOfRooms(){
 		println(“The number of rooms is \(numberOfRooms)”)
@@ -159,7 +176,7 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 
 这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型`Void`（参见Function Without Return Values）。
 
-如果你利用可选链调用此方法，这个方法的返回值类型将是`Void？`，而不是`Void`，因为当通过可选链调用方法时返回值总是自判断类型（optional type）。，即使是这个方法本是没有定义返回值，你也可以使用`if`语句来检查是否能成功调用`printNumberOfRooms`方法：如果方法通过可选链调用成功，`printNumberOfRooms`的隐式返回值将会是`Void`，如果没有成功，将返回`nil`：
+如果你利用可选链调用此方法，这个方法的返回值类型将是`Void?`，而不是`Void`，因为当通过可选链调用方法时返回值总是可选类型（optional type）。，即使是这个方法本是没有定义返回值，你也可以使用`if`语句来检查是否能成功调用`printNumberOfRooms`方法：如果方法通过可选链调用成功，`printNumberOfRooms`的隐式返回值将会是`Void`，如果没有成功，将返回`nil`：
 
 	if john.residence?.printNumberOfRooms() {
 	    println("It was possible to print the number of rooms.")
@@ -168,6 +185,7 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 	}
 	// 打印 "It was not possible to print the number of rooms."。
 
+
 ##使用可选链调用子脚本
 
 你可以使用可选链来尝试从子脚本获取值并检查子脚本的调用是否成功，然而，你不能通过可选链来设置子代码。
@@ -184,7 +202,7 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 	}
 	// 打印 "Unable to retrieve the first room name."。
 
-在子代码调用中可选链的问号直接跟在`john.residence`的后面，在子脚本括号的前面，因为`john.residence`是可选链试图获得的自判断值。
+在子代码调用中可选链的问号直接跟在`john.residence`的后面，在子脚本括号的前面，因为`john.residence`是可选链试图获得的可选值。
 
 如果你创建一个`Residence`实例给`john.residence`，且在他的`rooms`数组中有一个或多个`Room`实例，那么你可以使用可选链通过`Residence`子脚本来获取在`rooms`数组中的实例了：
 
@@ -200,20 +218,21 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 	}
 	// 打印 "The first room name is Living Room."。
 
+
 ##连接多层链接
 
-你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的自判断值更多的层。
+你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。
 也就是说：
 
-如果你试图获得的类型不是自判断类型，由于使用了可选链它将变成自判断类型。
-如果你试图获得的类型已经是自判断类型，由于可选链它也不会提高自判断性。
+如果你试图获得的类型不是可选类型，由于使用了可选链它将变成可选类型。
+如果你试图获得的类型已经是可选类型，由于可选链它也不会提高自判断性。
 
 因此：
 
-如果你试图通过可选链获得`Int`值，不论使用了多少层链接返回的总是`Int？`。
-相似的，如果你试图通过可选链获得`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 {
 	    println("John's street name is \(johnsStreet).")
@@ -224,7 +243,7 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 
 `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`属性设定一个实际值，你可以通过多层可选链来得到这个属性值。
 
@@ -240,13 +259,14 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 	}
 	// 打印 "John's street name is Laurel Street."。
 
-值得注意的是，“`!`”符的在定义`address`实例时的使用（`john.residence.address`）。`john.residence`属性是一个自判断类型，因此你需要在它获取`address`属性之前使用`！`解析以获得它的实际值。
+值得注意的是，“`!`”符的在定义`address`实例时的使用（`john.residence.address`）。`john.residence`属性是一个可选类型，因此你需要在它获取`address`属性之前使用`!`解析以获得它的实际值。
 
+
 ##链接自判断返回值的方法
 
-前面的例子解释了如何通过可选链来获得自判断类型属性值。你也可以通过调用返回自判断类型值的方法并按需链接方法的返回值。
+前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过调用返回可选类型值的方法并按需链接方法的返回值。
 
-下面的例子通过可选链调用了`Address`类中的`buildingIdentifier` 方法。这个方法的返回值类型是`String?`。如上所述，这个方法在可选链调用后最终的返回值类型依然是`String？`：
+下面的例子通过可选链调用了`Address`类中的`buildingIdentifier` 方法。这个方法的返回值类型是`String?`。如上所述，这个方法在可选链调用后最终的返回值类型依然是`String?`：
 
 	if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
 	    println("John's building identifier is \(buildingIdentifier).")
@@ -261,7 +281,7 @@ Residence的printNumberOfRooms方法会打印numberOfRooms的当前值。方法
 	// 打印 "John's uppercase building identifier is THE LARCHES."。
 
 > 注意：
-在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的自判断值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。
+在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是`buildingIdentifier`方法的返回值，不是`buildingIdentifier`方法本身。
 
 
 
diff --git a/source/chapter2/18_Type_Casting.md b/source/chapter2/18_Type_Casting.md
index 737eb681..4d420ea9 100644
--- a/source/chapter2/18_Type_Casting.md
+++ b/source/chapter2/18_Type_Casting.md
@@ -1,27 +1,30 @@
+> 翻译：xiehurricane
+
+> 校对：happyming
+
 # 类型检查（Type Casting）
 -----------------
 
-（ps：为了方便各位检验所以保留了英文，可删。）
-  _类型检查_是一种检查类实例的方式，并且哦或者也是让实例作为它的父类或者子类的一种方式。
+本页包含内容：
 
-  _Type casting_ is a way to check the type of an instance, and/or to treat that instance as if it is a different superclass or subclass from somewhere else in its own class hierarchy.
+- [定义一个类层次作为例子](#defining_a_class_hierarchy_for_type_casting)
+- [检查类型](#checking_type)
+- [向下转型（Downcasting）](#downcasting)
+- [`Any`和`AnyObject`的类型检查](#type_casting_for_any_and_anyobject)
 
-  类型检查在Swift中使用`is` 和 `as`操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
 
-  Type casting in Swift is implemented with the `is` and `as` operators. These two operators provide a simple and expressive way to check the type of a value or cast a value to a different type.
+  _类型检查_是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。
 
-  你也可以用来检查一个类是否实现了某个协议，就像在 [Protocols》Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
+  类型检查在 Swift 中使用`is` 和 `as`操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。
 
-  You can also use type casting to check whether a type conforms to a protocol, as described in [Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363).
-### 定义一个类层次作为例子Defining a Class Hierarchy for Type Casting
+  你也可以用来检查一个类是否实现了某个协议，就像在 [Protocols Checking for Protocol Conformance](Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363)部分讲述的一样。
 
-  你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个array包含了几个这些类的实例，作为类型检查的例子。
+
+## 定义一个类层次作为例子
 
-  You can use type casting with a hierarchy of classes and subclasses to check the type of a particular class instance and to cast that instance to another class within the same hierarchy. The three code snippets below define a hierarchy of classes and an array containing instances of those classes, for use in an example of type casting.
+  你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。
 
-  第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。）
-
-  The first snippet defines a new base class called `MediaItem`. This class provides basic functionality for any kind of item that appears in a digital media library. Specifically, it declares a `name` property of type `String`, and an `init name` initializer. (It is assumed that all media items, including all movies and songs, will have a name.)
+  第一个代码片段定义了一个新的基础类`MediaItem`。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 `String` 类型的 `name` 属性，和一个`init name`初始化器。（它假定所有的媒体项都有个名称。）
 
     class MediaItem {
         var name: String
@@ -32,16 +35,6 @@
 
   下一个代码段定义了 `MediaItem` 的两个子类。第一个子类`Movie`，在父类（或者说基类）的基础上增加了一个 `director`（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 `artist`（艺术家） 属性，和相应的初始化器：
 
-  The next snippet defines two subclasses of `MediaItem`. The first subclass, `Movie`, encapsulates additional information about a movie or film. It adds a `director` property on top of the base `MediaItem` class, with a corresponding initializer. The second subclass, `Song`, adds an `artist` property and initializer on top of the base class:
-
-    class Movie: MediaItem {
-        var director: String
-        init(name: String, director: String) {
-            self.director = director
-            super.init(name: name)
-        }
-    }
-
     class Song: MediaItem {
         var artist: String
         init(name: String, artist: String) {
@@ -50,9 +43,8 @@
         }
     }
 
-  最后一个代码段创建了一个array常量 `library` ，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它的array标记符和里面的内容（ps: literal： 标记符其实就是指“[”和“]”，虽然苹果官方的翻译里翻译为字面当总感觉不好理解，有点奇怪。不如翻译为标记符）推断来的。Swift的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。
-
-  The final snippet creates a constant array called `library`, which contains two `Movie` instances and three `Song` instances. The type of the `library` array is inferred by initializing it with the contents of an array literal. Swift’s type checker is able to deduce that `Movie` and `Song` have a common superclass of `MediaItem`, and so it infers a type of `MediaItem[]` for the `library` array:
+  最后一个代码段创建了一个数组常量 `library`
+  ，包含两个`Movie`实例和三个`Song`实例。`library`的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出`Movie` 和 `Song` 有共同的父类 `MediaItem` ，所以它推断出 `MediaItem[]` 类作为 `library` 的类型。
 
     let library = [
     Movie(name: "Casablanca", director: "Michael Curtiz"),
@@ -63,19 +55,14 @@
     ]
     // the type of "library" is inferred to be MediaItem[]
 
-  在幕后`library` 里存储的项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。
+  在幕后`library` 里存储的媒体项依然是 `Movie` 和 `Song` 类型的，但是，若你迭代它，取出的实例会是 `MediaItem` 类型的，而不是 `Movie` 和 `Song` 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。
 
-  The items stored in `library` are still `Movie` and `Song` instances behind the scenes. However, if you iterate over the contents of this array, the items you receive back are typed as `MediaItem`, and not as `Movie` or `Song`. In order to work with them as their native type, you need to _check_ their type, or _downcast_ them to a different type, as described below.
-
-### 检查类型 Checking Type
+
+## 检查类型
 
   用类型检查操作符(`is`)来检查一个实例是否属于特定子类型。类型检查操作符返回 `true` 若实例属于那个子类型，若不属于返回 `false` 。
 
-  Use the _type check operator_ (`is`) to check whether an instance is of a certain subclass type. The type check operator returns `true` if the instance is of that subclass type and `false` if it is not.
-
-  下面的例子定义了连个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。
-
-  The example below defines two variables, `movieCount` and `songCount`, which count the number of `Movie` and `Song` instances in the `library` array:
+  下面的例子定义了两个变量，`movieCount` 和 `songCount`，用来计算数组`library` 中 `Movie` 和 `Song` 类型的实例数量。
 
     var movieCount = 0
     var songCount = 0
@@ -92,39 +79,26 @@
     // prints "Media library contains 2 movies and 3 songs"
 
   示例迭代了数组 `library` 中的所有项。每一次， `for`-`in` 循环设置
-  `item` 常量的值为数组中的下一个 `MediaItem`。
+  `item` 为数组中的下一个 `MediaItem`。
 
-  This example iterates through all items in the `library` array. On each pass, the `for`-`in` loop sets the `item` constant to the next `MediaItem` in the array.
+  若当前 `MediaItem` 是一个 `Movie` 类型的实例， `item is Movie` 返回
+  `true`，相反返回 `false`。同样的，`item is
+  Song`检查item是否为`Song`类型的实例。在循环结束后，`movieCount` 和 `songCount`的值就是被找到属于各自的类型的实例数量。
 
-  若当前 `MediaItem` 是一个 `Movie` 类型的实例， `item is Movie` 返回 `true`，相反返回 `false`。同样的，`item is Song`检查item是否为`Song`类型的实例。在循环末尾，`movieCount` 和 `songCount`的值就是被找到属于各自的类型的实例数量。
-
-  `item is Movie` returns `true` if the current `MediaItem` is a `Movie` instance and `false` if it is not. Similarly, `item is Song` checks whether the item is a `Song` instance. At the end of the `for`-`in` loop, the values of `movieCount` and `songCount` contain a count of how many `MediaItem` instances were found of each type.
-
-### 向下转型（简称下转） Downcasting
+
+## 向下转型（Downcasting）
 
   某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型检查操作符(`as`)
 
-  A constant or variable of a certain class type may actually refer to an instance of a subclass behind the scenes. Where you believe this is the case, you can try to _downcast_ to the subclass type with the _type cast operator_ (`as`).
-
   因为向下转型可能会失败，类型检查操作符带有两种不同形式。可选形式（ optional form） `as?` 返回一个你试图下转成的类型的可选值（optional value）。强制形式 `as` 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。
 
-  Because downcasting can fail, the type cast operator comes in two different forms. The optional form, `as?`, returns an optional value of the type you are trying to downcast to. The forced form, `as`, attempts the downcast and force-unwraps the result as a single compound action.
-
   当你不确定下转可以成功时，用类型检查的可选形式(`as?`)。可选形式的类型检查总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 `nil` 。这使你能够检查下转是否成功。
 
-  Use the optional form of the type cast operator (`as?`) when you are not sure if the downcast will succeed. This form of the operator will always return an optional value, and the value will be `nil` if the downcast was not possible. This enables you to check for a successful downcast.
+  只有你可以确定下转一定会成功时，才使用强制形式。当你试图下转为一个不正确的类型时，强制形式的类型检查会触发一个运行时错误。
 
-  只有你可以确定下转一定会成功时，才使用强制形式。当你试图下转为一个不正确的类型时，强制形式的类型检查会触发一个runtime error。
+  下面的例子，迭代了`library`里的每一个 `MediaItem` ，并打印出适当的描述。要这样做，`item`需要真正作为`Movie` 或 `Song`的类型来使用。不仅仅是作为 `MediaItem`。为了能够使用`Movie` 或 `Song`的 `director` 或 `artist`属性，这是必要的。
 
-  Use the forced form of the type cast operator (`as`) only when you are sure that the downcast will always succeed. This form of the operator will trigger a runtime error if you try to downcast to an incorrect class type.
-
-  下面的例子，迭代了`library`里的每一个 `MediaItem` ，并打印出适当的描述。要这样做，item需要真正作为`Movie` 或 `Song`的类型来使用。不仅仅是作为 `MediaItem`。为了能够使用`Movie` 或 `Song`的 `director` 或 `artist`属性，这是必要的。
-
-  The example below iterates over each `MediaItem` in `library`, and prints an appropriate description for each item. To do this, it needs to access each item as a true `Movie` or `Song`, and not just as a `MediaItem`. This is necessary in order for it to be able to access the `director` or `artist` property of a `Movie` or `Song` for use in the description.
-
-  在这个示例中，数组中的每一个item可能是 `Movie` 或 `Song`。   事前你不知道每个item的真实类型，所以这里使用可选形式的类型检查 (`as?`)去检查循环里的每次下转。
-
-  In this example, each item in the array might be a `Movie`, or it might be a `Song`. You don’t know in advance which actual class to use for each item, and so it is appropriate to use the optional form of the type cast operator (`as?`) to check the downcast each time through the loop:
+  在这个示例中，数组中的每一个`item`可能是 `Movie` 或 `Song`。   事前你不知道每个`item`的真实类型，所以这里使用可选形式的类型检查 （`as?`）去检查循环里的每次下转。
 
     for item in library {
         if let movie = item as? Movie {
@@ -140,31 +114,23 @@
     // Song: 'The One And Only', by Chesney Hawkes
     // Song: 'Never Gonna Give You Up', by Rick Astley
 
-  示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem` 类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类 `MediaItem`。因为不确定，`as?`形式试图下转时返还一个可选值。 `item as Movie` 的返回值是`Movie?`类型或 “optional `Movie`”。
+  示例首先试图将 `item` 下转为 `Movie`。因为 `item` 是一个 `MediaItem`
+  类型的实例，它可能是一个`Movie`；同样，它可能是一个 `Song`，或者仅仅是基类
+  `MediaItem`。因为不确定，`as?`形式在试图下转时将返还一个可选值。 `item as Movie` 的返回值是`Movie?`类型或 “optional `Movie`”。
 
-  The example starts by trying to downcast the current `item` as a `Movie`. Because `item` is a `MediaItem` instance, it’s possible that it _might_ be a `Movie`; equally, it’s also possible that it might a `Song`, or even just a base `MediaItem`. Because of this uncertainty, the `as?` form of the type cast operator returns an _optional_ value when attempting to downcast to a subclass type. The result of `item as Movie` is of type `Movie?`, or “optional `Movie`”.
+  当下转为 `Movie` 应用在两个 `Song`
+  实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 `Movie`真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”，可以这样解读：
 
-  当应用在两个`Song`实例时，下转为 `Movie` 失败。为了处理这种情况，上面的实例使用了可选绑定（optional binding）来检查optional `Movie`真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“`if let movie = item as? Movie`”,可以这样解读：
-
-  Downcasting to `Movie` fails when applied to the two `Song` instances in the library array. To cope with this, the example above uses optional binding to check whether the optional `Movie` actually contains a value (that is, to find out whether the downcast succeeded.) This optional binding is written “`if let movie = item as? Movie`”, which can be read as:
-
-  “尝试将 `item` 转为 `Movie`类型。若成功，设置一个新的临时常量 `movie`  来存储返回的optional `Movie`”
-
-  “Try to access `item` as a `Movie`. If this is successful, set a new temporary constant called `movie` to the value stored in the returned optional `Movie`.”
+  “尝试将 `item` 转为 `Movie`类型。若成功，设置一个新的临时常量 `movie`  来存储返回的可选`Movie`”
 
   若下转成功，然后`movie`的属性将用于打印一个`Movie`实例的描述，包括它的导演的名字`director`。当`Song`被找到时，一个相近的原理被用来检测 `Song` 实例和打印它的描述。
 
-  If the downcasting succeeds, the properties of `movie` are then used to print a description for that `Movie` instance, including the name of its `director`. A similar principle is used to check for `Song` instances, and to print an appropriate description (including `artist` name) whenever a `Song` is found in the library.
+> 注意：
+>
+转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
 
-    注意
-
-    转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。
-
-    NOTE
-
-    Casting does not actually modify the instance or change its values. The underlying instance remains the same; it is simply treated and accessed as an instance of the type to which it has been cast.
-
-### Any和AnyObject的转换 Type Casting for Any and AnyObject
+
+## `Any`和`AnyObject`的类型检查
 
   Swift为不确定类型提供了两种特殊类型别名：
 
@@ -172,34 +138,19 @@
 
   *   `Any`可以表示任何类型，除了方法类型（function types）。
 
-  Swift provides two special type aliases for working with non-specific types:
+> 注意：
+>
+只有当你明确的需要它的行为和功能时才使用`Any`和`AnyObject`。在你的代码里使用你期望的明确的类型总是更好的。
 
-*   `AnyObject` can represent an instance of any class type.
-*   `Any` can represent an instance of any type at all, apart from function types.
+### `AnyObject`类型
 
-        注意
+  当需要在工作中使用 Cocoa
+  APIs，它一般接收一个`AnyObject[]`类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。
 
-        只有当你明确的需要它的行为和功能时才使用Any和AnyObject。在你的代码里使用你期望的明确的类型总是更好的。
-
-        NOTE
-
-        Use Any and AnyObject only when you explicitly need the behavior and capabilities they provide. It is always better to be specific about the types you expect to work with in your code.
-
-
-### AnyObject类型
-
-  当需要在工作中使用Cocoa APIs，它一般接收一个`AnyObject[]`类型的数组，或者说“一个任何对象类型的数组”。这是因为OC没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的API信息提供的这样一个数组中的对象的类型。
-
-  When working with Cocoa APIs, it is common to receive an array with a type of `AnyObject[]`, or “an array of values of any object type”. This is because Objective-C does not have explicitly typed arrays. However, you can often be confident about the type of objects contained in such an array just from the information you know about the API that provided the array.
-
-  在这些情况下，你可以使用强制形式的类型检查(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解包（optional unwrapping）。
-
-  In these situations, you can use the forced version of the type cast operator (`as`) to downcast each item in the array to a more specific class type than `AnyObject`, without the need for optional unwrapping.
+  在这些情况下，你可以使用强制形式的类型检查(`as`)来下转在数组中的每一项到比 `AnyObject` 更明确的类型，不需要可选解析（optional unwrapping）。
 
   下面的示例定义了一个 `AnyObject[]` 类型的数组并填入三个`Movie`类型的实例：
 
-  The example below defines an array of type `AnyObject[]` and populates this array with three instances of the `Movie` class:
-
     let someObjects: AnyObject[] = [
         Movie(name: "2001: A Space Odyssey", director: "Stanley Kubrick"),
         Movie(name: "Moon", director: "Duncan Jones"),
@@ -208,8 +159,6 @@
 
   因为知道这个数组只包含 `Movie` 实例，你可以直接用(`as`)下转并解包到不可选的`Movie`类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。
 
-  Because this array is known to contain only `Movie` instances, you can downcast and unwrap directly to a non-optional `Movie` with the forced version of the type cast operator (`as`):
-
     for object in someObjects {
         let movie = object as Movie
         println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -218,9 +167,7 @@
     // Movie: 'Moon', dir. Duncan Jones
     // Movie: 'Alien', dir. Ridley Scott
 
-  为了变为一个更短的形式，下转`someObjects`类型成功 `Movie[]` 类型代替下转每一项。
-
-  For an even shorter form of this loop, downcast the `someObjects` array to a type of `Movie[]` instead of downcasting each item:
+  为了变为一个更短的形式，下转`someObjects`数组为`Movie[]`类型来代替下转每一项方式。
 
     for movie in someObjects as Movie[] {
         println("Movie: '\(movie.name)', dir. \(movie.director)")
@@ -229,11 +176,9 @@
     // Movie: 'Moon', dir. Duncan Jones
     // Movie: 'Alien', dir. Ridley Scott
 
-### Any类型
+### `Any`类型
 
-  这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非class类型。它创建了一个可以存储`Any`类型的数组 `things`。
-
-  Here’s an example of using `Any` to work with a mix of different types, including non-class types. The example creates an array called `things`, which can store values of type `Any`:
+  这里有个示例，使用 `Any` 类型来和混合的不同类型一起工作，包括非`class`类型。它创建了一个可以存储`Any`类型的数组 `things`。
 
     var things = Any[]()
 
@@ -245,14 +190,10 @@
     things.append((3.0, 5.0))
     things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
 
-  `things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman导演的电影“Ghostbusters”。
-
-  The `things` array contains two `Int` values, two `Double` values, a `String` value, a tuple of type `(Double, Double)`, and the movie “Ghostbusters”, directed by Ivan Reitman.
+  `things` 数组包含两个 `Int` 值，2个 `Double` 值，1个 `String` 值，一个元组 `(Double, Double)` ，Ivan Reitman 导演的电影“Ghostbusters”。
 
   你可以在 `switch` `cases`里用`is` 和 `as` 操作符来发觉只知道是 `Any` 或 `AnyObject`的常量或变量的类型。 下面的示例迭代 `things`数组中的每一项的并用`switch`语句查找每一项的类型。这几种`switch`语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：
 
-  You can use the `is` and `as` operators in a `switch` statement’s cases to discover the specific type of a constant or variable that is known only to be of type `Any` or `AnyObject`. The example below iterates over the items in the `things` array and queries the type of each item with a `switch` statement. Several of the `switch` statement’s cases bind their matched value to a constant of the specified type to enable its value to be printed:
-
     for thing in things {
         switch thing {
         case 0 as Int:
@@ -285,10 +226,6 @@
     // a movie called 'Ghostbusters', dir. Ivan Reitman
 。
 
-    注意
-
-    在一个switch语句的case中使用强制形式的类型检查操作符(as, 而不是 as?) 来检查和转换到一个规定的类型。在switch case 语句的内容中这种检查总是安全的。
-
-    NOTE
-
-    The cases of a switch statement use the forced version of the type cast operator (as, not as?) to check and cast to a specific type. This check is always safe within the context of a switch case statement.
+> 注意：
+>
+在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。
diff --git a/source/chapter2/19_Nested_Types.md b/source/chapter2/19_Nested_Types.md
index b25c35ae..5edc7930 100644
--- a/source/chapter2/19_Nested_Types.md
+++ b/source/chapter2/19_Nested_Types.md
@@ -1,15 +1,20 @@
+> 翻译：Lin-H
+
+> 校对：shinyzhu
+
 # 类型嵌套
 -----------------
 
 本页包含内容：
 
--   类型嵌套实例
--   类型嵌套的引用
+-   [类型嵌套实例](#nested_types_in_action)
+-   [类型嵌套的引用](#referring_to_nested_types)
 
 枚举类型常被用于实现特定类或结构体的功能。也能够在有多种变量类型的环境中，方便地定义通用类或结构体来使用，为了实现这种功能，Swift允许你定义类型嵌套，可以在枚举类型、类和结构体中定义支持嵌套的类型。
 
 要在一个类型中嵌套另一个类型，将需要嵌套的类型的定义写在被嵌套类型的区域{}内，而且可以根据需要定义多级嵌套。
 
+
 ##类型嵌套实例
 
 下面这个例子定义了一个结构体`BlackjackCard`(二十一点)，用来模拟`BlackjackCard`中的扑克牌点数。`BlackjackCard`结构体包含2个嵌套定义的枚举类型`Suit` 和 `Rank`。
@@ -72,6 +77,7 @@
 
 尽管`Rank`和`Suit`嵌套在`BlackjackCard`中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中`description`属性能正确得输出对`Ace`牌有1和11两个值。
 
+
 ##类型嵌套的引用
 
 在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名：
@@ -79,4 +85,4 @@
     let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
     // 红心的符号 为 "♡"
 
-对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。
\ No newline at end of file
+对于上面这个例子，这样可以使`Suit`, `Rank`, 和 `Values`的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。
diff --git a/source/chapter2/20_Extensions.md b/source/chapter2/20_Extensions.md
index 1999b308..1108be7a 100644
--- a/source/chapter2/20_Extensions.md
+++ b/source/chapter2/20_Extensions.md
@@ -1,59 +1,63 @@
-#扩展（Extensions）
+> 翻译：lyuka
 
+> 校对：Hawstein
+
+#扩展（Extensions）
 ----
 
 本页包含内容：
 
--   扩展语法（Extension Syntax）
--   计算属性（Computed Properties）
--   构造器（Initializers）
--   方法（Methods）
--   下标（Subscripts）
--   嵌套类型（Nested Types）
+- [扩展语法](#extension_syntax)
+- [计算型属性](#computed_properties)
+- [构造器](#initializers)
+- [方法](#methods)
+- [下标](#subscripts)
+- [嵌套类型](#nested_types)
 
-*扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和Objective-C中的分类(categories)类似。（不过与Objective-C不同的是，Swift的扩展没有名字。）
+*扩展*就是向一个已有的类、结构体或枚举类型添加新功能（functionality）。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即*逆向建模*）。扩展和 Objective-C 中的分类（categories）类似。（不过与Objective-C不同的是，Swift 的扩展没有名字。）
 
-Swift中的扩展可以：
+Swift 中的扩展可以：
 
--   添加计算属性和计算静态属性
--   定义实例方法和类型方法
--   提供新的构造器
--   定义下标
--   定义和使用新的嵌套类型
--   使一个已有类型符合某个接口
+- 添加计算型属性和计算静态属性
+- 定义实例方法和类型方法
+- 提供新的构造器
+- 定义下标
+- 定义和使用新的嵌套类型
+- 使一个已有类型符合某个接口
 
 
->注意
+>注意：
+>
 如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。
 
-
-##扩展语法
+
+## 扩展语法（Extension Syntax）
 
 声明一个扩展使用关键字`extension`：
 
-```javascript
-extension SomeType{
-    // new functionality to add to SomeType goes here
+```
+extension SomeType {
+    // 加到SomeType的新功能写到这里
 }
 ```
 
-一个扩展可以扩展一个已有类型，使其能够适配一个或多个接口。当这种情况发生时，接口的名字应该完全按照类或结构体的名字的方式进行书写：
+一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，接口的名字应该完全按照类或结构体的名字的方式进行书写：
 
-```javascript
-extension SomeType: SomeProtocol, AnotherProctocol{
-    // implementation of protocol requirments goes here
+```
+extension SomeType: SomeProtocol, AnotherProctocol {
+    // 协议实现写到这里
 }
 ```
 
-按照这种方式添加的接口一致性被称之为**给扩展添加接口一致性(Protocal Conformance)**
+按照这种方式添加的协议遵循者（protocol conformance）被称之为[在扩展中添加协议遵循者](21_Protocols.html#adding_protocol_conformance_with_an_extension)
 
+
+## 计算型属性（Computed Properties）
 
-##计算属性
+扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建`Double`类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。
 
-扩展可以向已有类型添加计算实例属性和计算类型属性。下面的例子向Swift的内建`Double`类型添加了5个计算实例属性，从而提供与距离单位协作的基本支持。
-
-```javascript
-extension Double{
+```
+extension Double {
     var km: Double { return self * 1_000.0 }
     var m : Double { return self }
     var cm: Double { return self / 100.0 }
@@ -62,48 +66,52 @@ extension Double{
 }
 let oneInch = 25.4.mm
 println("One inch is \(oneInch) meters")
-// prints "One inch is 0.0254 meters"
+// 打印输出："One inch is 0.0254 meters"
 let threeFeet = 3.ft
 println("Three feet is \(threeFeet) meters")
-// prints "Three feet is 0.914399970739201 meters"
+// 打印输出："Three feet is 0.914399970739201 meters"
 ```
 
-这些计算属性表达的含义是把一个`Double`型的值看作是某单位下的长度值。即使它们被实现为计算属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。
+这些计算属性表达的含义是把一个`Double`型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。
 
-在上述例子中，一个`Double`型的值`1.0`被用来表示“1米”。这就是为什么`m`计算属性返回`self`——表达式`1.m`被认为是计算`1.0`的`Double`值。
+在上述例子中，一个`Double`型的值`1.0`被用来表示“1米”。这就是为什么`m`计算型属性返回`self`——表达式`1.m`被认为是计算`1.0`的`Double`值。
 
-其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以`km`计算属性要把值乘以`1_000.00`来转化成单位米下的数值。类似地，1米有3.28024英尺，所以`ft`计算属性要把对应的`Double`值除以`3.28024`来实现英尺到米的单位换算。
+其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以`km`计算型属性要把值乘以`1_000.00`来转化成单位米下的数值。类似地，1米有3.28024英尺，所以`ft`计算型属性要把对应的`Double`值除以`3.28024`来实现英尺到米的单位换算。
 
-这些属性是只读的计算属性，所有从简考虑它们不用`get`关键字表示。它们的返回值是`Double`型，而且可以用于所有接受`Double`的数学计算中：
+这些属性是只读的计算型属性，所有从简考虑它们不用`get`关键字表示。它们的返回值是`Double`型，而且可以用于所有接受`Double`的数学计算中：
 
-```javascript
+```
 let aMarathon = 42.km + 195.m
 println("A marathon is \(aMarathon) meters long")
-// prints "A marathon is 42495.0 meters long"
+// 打印输出："A marathon is 42495.0 meters long"
 ```
 
 
->注意
+>注意：
+>
 扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。
 
-##构造器
+
+## 构造器（Initializers）
 
 扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。
 
 
->注意
+> 注意：
+>
 如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和成员级构造器(memberwise initializers)。
 正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。
 
 下面的例子定义了一个用于描述几何矩形的定制结构体`Rect`。这个例子同时定义了两个辅助结构体`Size`和`Point`，它们都把`0.0`作为所有属性的默认值：
-```javascript
-struct Size{
+
+```
+struct Size {
     var width = 0.0, height = 0.0
 }
-struct Point{
+struct Point {
     var x = 0.0, y = 0.0
 }
-struct Rect{
+struct Rect {
     var origin = Point()
     var size = Size()
 }
@@ -111,16 +119,17 @@ struct Rect{
 
 因为结构体`Rect`提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的`Rect`实例：
 
-```javascript
+```
 let defaultRect = Rect()
-let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0), 
+let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
     size: Size(width: 5.0, height: 5.0))
 ```
 
 你可以提供一个额外的使用特殊中心点和大小的构造器来扩展`Rect`结构体：
-```javascript
-extension Rect{
-    init(center: Point, size: Size){
+
+```
+extension Rect {
+    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)
@@ -129,23 +138,27 @@ extension Rect{
 ```
 
 这个新的构造器首先根据提供的`center`和`size`值计算一个合适的原点。然后调用该结构体自动的成员构造器`init(origin:size:)`，该构造器将新的原点和大小存到了合适的属性中：
-```javascript
+
+```
 let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
     size: Size(width: 3.0, height: 3.0))
-// centerRect's origin is (2.5, 2.5) and its size is (3.0, 3.0)
+// centerRect的原点是 (2.5, 2.5)，大小是 (3.0, 3.0)
 ```
 
 
->注意
+>注意：
+>
 如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。
 
-##方法
+
+## 方法（Methods）
 
 扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向`Int`类型添加一个名为`repetitions`的新实例方法：
-```javascript
-extension Int{
-    func repetitions(task: () -> ()){
-        for i in 0..self{
+
+```
+extension Int {
+    func repetitions(task: () -> ()) {
+        for i in 0..self {
             task()
         }
     }
@@ -155,7 +168,8 @@ extension Int{
 这个`repetitions`方法使用了一个`() -> ()`类型的单参数（single argument），表明函数没有参数而且没有返回值。
 
 定义该扩展之后，你就可以对任意整数调用`repetitions`方法,实现的功能则是多次执行某任务：
-```javascript
+
+```
 3.repetitions({
     println("Hello!")
     })
@@ -164,8 +178,9 @@ extension Int{
 // Hello!
 ```
 
-可以使用trailing闭包使调用更加简洁：
-```javascript
+可以使用 trailing 闭包使调用更加简洁：
+
+```
 3.repetitions{
     println("Goodbye!")
 }
@@ -174,36 +189,39 @@ extension Int{
 // Goodbye!
 ```
 
-###修改实例方法
+
+### 修改实例方法（Mutating Instance Methods）
 
 通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改`self`或其属性的方法必须将该实例方法标注为`mutating`，正如来自原始实现的修改方法一样。
 
 下面的例子向Swift的`Int`类型添加了一个新的名为`square`的修改方法，来实现一个原始值的平方计算：
-```javascript
-extension Int{
-    mutating func square(){
+
+```
+extension Int {
+    mutating func square() {
         self = self * self
     }
 }
 var someInt = 3
 someInt.square()
-// someInt is now 9
+// someInt 现在值是 9
 ```
 
-##下标
+
+## 下标（Subscripts）
 
 扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型`Int`添加了一个整型下标。该下标`[n]`返回十进制数字从右向左数的第n个数字
 
--   123456789[0]返回9
--   123456789[1]返回8
+- 123456789[0]返回9
+- 123456789[1]返回8
 
-等等
+...等等
 
-```javascript
-extension Int{
+```
+extension Int {
     subscript(digitIndex: Int) -> Int {
         var decimalBase = 1
-            for _ in 1...digitIndex{
+            for _ in 1...digitIndex {
                 decimalBase *= 10
             }
         return (self / decimalBase) % 10
@@ -220,16 +238,19 @@ extension Int{
 ```
 
 如果该`Int`值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：
-```javascript
+
+```
 746381295[9]
 //returns 0, 即等同于：
 0746381295[9]
 ```
 
-##嵌套类型
+
+## 嵌套类型（Nested Types）
 
 扩展可以向已有的类、结构体和枚举添加新的嵌套类型：
-```javascript
+
+```
 extension Character {
     enum Kind {
         case Vowel, Consonant, Other
@@ -253,9 +274,10 @@ extension Character {
 这个类子还向`Character`添加了一个新的计算实例属性，即`kind`，用来返回合适的`Kind`枚举成员。
 
 现在，这个嵌套枚举可以和一个`Character`值联合使用了：
-```javascript
+
+```
 func printLetterKinds(word: String) {
-    println("'\\(word)' is made up of the following kinds   of letters:")
+    println("'\\(word)' is made up of the following kinds of letters:")
     for character in word {
         switch character.kind {
         case .Vowel:
@@ -275,5 +297,6 @@ printLetterKinds("Hello")
 
 函数`printLetterKinds`的输入是一个`String`值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的`kind`计算属性，并打印出合适的类别描述。所以`printLetterKinds`就可以用来打印一个完整单词中所有字母的类型，正如上述单词`"hello"`所展示的。
 
->注意
+>注意：
+>
 由于已知`character.kind`是`Character.Kind`型，所以`Character.Kind`中的所有成员值都可以使用`switch`语句里的形式简写，比如使用 `.Vowel`代替`Character.Kind.Vowel`
diff --git a/source/chapter2/21_Protocols.md b/source/chapter2/21_Protocols.md
index a0dd63c1..77665dab 100644
--- a/source/chapter2/21_Protocols.md
+++ b/source/chapter2/21_Protocols.md
@@ -1,43 +1,65 @@
+> 翻译：geek5nan
+
+> 校对：dabing1022
+
 # 协议
 -----------------
 
-`Protocol(协议)`用于**统一**方法和属性的名称,而不实现任何功能,(*译者注: 协议在其他语言中也称作`接口(Interface)`*).`协议`能够被`类`,`枚举`,`结构体`实现,满足协议要求的`类`,`枚举`,`结构体`被称为协议的`遵循者`.
+本页包含内容：
 
-`遵循者`需要提供`协议`指定的成员,如`属性`,`方法`,`操作符`,`下标`等.
+- [协议的语法（Protocol Syntax）](#protocol_syntax)
+- [属性要求（Property Requirements）](#property_requirements)
+- [方法要求（Method Requirements）](#method_requirements)
+- [突变方法要求（Mutating Method Requirements）](#mutating_method_requirements)
+- [协议类型（Protocols as Types）](#protocols_as_types)
+- [委托(代理)模式（Delegation）](#delegation)
+- [在扩展中添加协议成员（Adding Protocol Conformance with an Extension）](#adding_protocol_conformance_with_an_extension)
+- [通过延展补充协议声明（Declaring Protocol Adoption with an Extension）](#declaring_protocol_adoption_with_an_extension)
+- [集合中的协议类型（Collections of Protocol Types）](#collections_of_protocol_types)
+- [协议的继承（Protocol Inheritance）](#protocol_inheritance)
+- [协议合成（Protocol Composition）](#protocol_composition)
+- [检验协议的一致性（Checking for Protocol Conformance）](#checking_for_protocol_conformance)
+- [可选协议要求（Optional Protocol Requirements）](#optional_protocol_requirements)
 
+`Protocol(协议)`用于**统一**方法和属性的名称，而不实现任何功能。`协议`能够被类，枚举，结构体实现，满足协议要求的类，枚举，结构体被称为协议的`遵循者`。
+
+`遵循者`需要提供`协议`指定的成员，如属性，方法，操作符，下标等。
+
+
 ## 协议的语法
 
-`协议`的定义与`类,结构体,枚举`的定义非常相似,如下所示:
+`协议`的定义与类，结构体，枚举的定义非常相似，如下所示：
 
 	protocol SomeProtocol {
 		// 协议内容
 	}
 
 
-在`类`,`结构体`,`枚举`的名称后加上`协议名称`,中间以冒号`:`分隔即可实现协议;实现多个协议时,各协议之间用逗号`,`分隔,如下所示:
+在类，结构体，枚举的名称后加上`协议名称`，中间以冒号`:`分隔即可实现协议；实现多个协议时，各协议之间用逗号`,`分隔，如下所示：
 
 	struct SomeStructure: FirstProtocol, AnotherProtocol {
 		// 结构体内容
 	}
 
-当某个类含有`父类`的同时并实现了协议,应当把`父类`放在所有的`协议`之前,如下所示:
+当某个类含有父类的同时并实现了协议，应当把父类放在所有的协议之前，如下所示：
 
 	class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
 		// 类的内容
 	}
 
+
 ## 属性要求
 
-`协议`能够要求其`遵循者`必须含有一些**特定名称和类型**的`实例属性(instance property)`或`类属性 (type property)`,也能够要求属性的`(设置权限)settable` 和`(访问权限)gettable`,但它不要求`属性`是`存储型属性(stored property)`还是`计算型属性(calculate property)`.
+`协议`能够要求其`遵循者`必须含有一些**特定名称和类型**的`实例属性(instance property)`或`类属性 (type property)`，也能够要求属性的`(设置权限)settable` 和`(访问权限)gettable`，但它不要求`属性`是`存储型属性(stored property)`还是`计算型属性(calculate property)`。
 
-通常前置`var`关键字将属性声明为变量.在属性声明后写上`{ get set }`表示属性为可读写的.`{ get }`用来表示属性为可读的.即使你为可读的属性实现了`setter`方法,它也不会出错.
+通常前置`var`关键字将属性声明为变量。在属性声明后写上`{ get set }`表示属性为可读写的。`{ get }`用来表示属性为可读的。即使你为可读的属性实现了`setter`方法，它也不会出错。
 
 	protocol SomeProtocol {
 		var musBeSettable : Int { get set }
 		var doesNotNeedToBeSettable: Int { get }
 	}
 
-用`类`来实现`协议`时,使用`class`关键字来表示该属性为类成员;用`结构体`或`枚举`实现`协议`时,则使用`static`关键字来表示:
+用类来实现协议时，使用`class`关键字来表示该属性为类成员；用结构体或枚举实现协议时，则使用`static`关键字来表示：
 
 	protocol AnotherProtocol {
 		class var someTypeProperty: Int { get set }
@@ -47,7 +69,7 @@
 		var fullName: String { get }
 	}
 
-`FullyNamed`协议含有`fullName`属性.因此其`遵循者`必须含有一个名为`fullName`,类型为`String`的可读属性.
+`FullyNamed`协议含有`fullName`属性。因此其`遵循者`必须含有一个名为`fullName`，类型为`String`的可读属性。
 
 	struct Person: FullyNamed{
 		var fullName: String
@@ -55,9 +77,9 @@
 	let john = Person(fullName: "John Appleseed")
 	//john.fullName 为 "John Appleseed"
 
-`Person`结构体含有一个名为`fullName`的`存储型属性`,完整的`遵循`了协议.(*若协议未被完整遵循,编译时则会报错*).
+`Person`结构体含有一个名为`fullName`的`存储型属性`，完整的`遵循`了协议。(*若协议未被完整遵循，编译时则会报错*)。
 
-如下所示,`Startship`类`遵循`了`FullyNamed`协议:
+如下所示，`Startship`类`遵循`了`FullyNamed`协议：
 
 	class Starship: FullyNamed {
 		var prefix: String?
@@ -73,15 +95,18 @@
 	var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
 	// ncc1701.fullName == "USS Enterprise"
 
-`Starship`类将`fullName`实现为可读的`计算型属性`.它的每一个实例都有一个名为`name`的必备属性和一个名为`prefix`的可选属性. 当`prefix`存在时,将`prefix`插入到`name`之前来为`Starship`构建`fullName`
+`Starship`类将`fullName`实现为可读的`计算型属性`。它的每一个实例都有一个名为`name`的必备属性和一个名为`prefix`的可选属性。 当`prefix`存在时，将`prefix`插入到`name`之前来为`Starship`构建`fullName`。
 
+
 ## 方法要求
 
-`协议`能够要求其`遵循者`必备某些特定的`实例方法`和`类方法`.协议方法的声明与普通方法声明相似,但它不需要`方法`内容.
+`协议`能够要求其`遵循者`必备某些特定的`实例方法`和`类方法`。协议方法的声明与普通方法声明相似，但它不需要`方法`内容。
 
-> 笔记: 协议方法支持`变长参数(variadic parameter)`,不支持`默认参数(default parameter)`.
+> 注意：
+>
+协议方法支持`变长参数(variadic parameter)`，不支持`默认参数(default parameter)`。
 
-前置`class`关键字表示协议中的成员为`类成员`;当协议用于被`枚举`或`结构体`遵循时,则使用`static`关键字. 如下所示:
+前置`class`关键字表示协议中的成员为`类成员`；当协议用于被`枚举`或`结构体`遵循时，则使用`static`关键字。如下所示：
 
 	protocol SomeProtocol {
 		class func someTypeMethod()
@@ -91,9 +116,9 @@
 		func random() -> Double
 	}
 
-`RandomNumberGenerator`协议要求其`遵循者`必须拥有一个名为`random`, 返回值类型为`Double`的实例方法. (我们假设随机数在[0,1]区间内).
+`RandomNumberGenerator`协议要求其`遵循者`必须拥有一个名为`random`， 返回值类型为`Double`的实例方法。(我们假设随机数在[0，1]区间内)。
 
-`LinearCongruentialGenerator`类`遵循`了`RandomNumberGenerator`协议,并提供了一个叫做*线性同余生成器(linear congruential generator)*的伪随机数算法.
+`LinearCongruentialGenerator`类`遵循`了`RandomNumberGenerator`协议，并提供了一个叫做*线性同余生成器(linear congruential generator)*的伪随机数算法。
 
 	class LinearCongruentialGenerator: RandomNumberGenerator {
 		var lastRandom = 42.0
@@ -111,23 +136,26 @@
 	println("And another one: \(generator.random())")
 	// 输出 : "And another one: 0.729023776863283"
 
+
 ## 突变方法要求
 
-能在`方法`或`函数`内部改变实例类型的方法称为`突变方法`.在`值类型(Value Type)`(*译者注:特指结构体和枚举*)中的的`函数`前缀加上`mutating`关键字来表示该函数允许改变该实例和其属性的类型. 这一变换过程在[Modifyting Value Types from Within Instance Methods](1)章节中有详细描述.
+能在`方法`或`函数`内部改变实例类型的方法称为`突变方法`。在`值类型(Value Type)`(*译者注：特指结构体和枚举*)中的的`函数`前缀加上`mutating`关键字来表示该函数允许改变该实例和其属性的类型。 这一变换过程在[实例方法(Instance Methods)](11_Methods.html#instance_methods)章节中有详细描述。
 
-(*译者注:类中的成员为`引用类型(Reference Type)`,可以方便的修改实例及其属性的值而无需改变类型;而`结构体`和`枚举`中的成员均为`值类型(Value Type)`,修改变量的值就相当于修改变量的类型,而`Swift`默认不允许修改类型,因此需要前置`mutating`关键字用来表示该`函数`中能够修改类型*)
+(*译者注：类中的成员为`引用类型(Reference Type)`，可以方便的修改实例及其属性的值而无需改变类型；而`结构体`和`枚举`中的成员均为`值类型(Value Type)`，修改变量的值就相当于修改变量的类型，而`Swift`默认不允许修改类型，因此需要前置`mutating`关键字用来表示该`函数`中能够修改类型*)
 
-> 注意: 用`类`实现协议中的`mutating`方法时,不用写`mutating`关键字;用`结构体`,`枚举`实现协议中的`mutating`方法时,必须写`mutating`关键字.
+> 注意：
+>
+用`class`实现协议中的`mutating`方法时，不用写`mutating`关键字；用`结构体`，`枚举`实现协议中的`mutating`方法时，必须写`mutating`关键字。
 
-如下所示,`Togglable`协议含有`toggle`函数.根据函数名称推测,`toggle`可能用于**切换或恢复**某个属性的状态.`mutating`关键字表示它为`突变方法`:
+如下所示，`Togglable`协议含有`toggle`函数。根据函数名称推测，`toggle`可能用于**切换或恢复**某个属性的状态。`mutating`关键字表示它为`突变方法`：
 
 	protocol Togglable {
 		mutating func toggle()
 	}
 
-当使用`枚举`或`结构体`来实现`Togglabl`协议时,必须在`toggle`方法前加上`mutating`关键字.
+当使用`枚举`或`结构体`来实现`Togglabl`协议时，必须在`toggle`方法前加上`mutating`关键字。
 
-如下所示,`OnOffSwitch`枚举`遵循`了`Togglable`协议,`On`,`Off`两个成员用于表示当前状态
+如下所示，`OnOffSwitch`枚举`遵循`了`Togglable`协议，`On`，`Off`两个成员用于表示当前状态
 
 	enum OnOffSwitch: Togglable {
 		case Off, On
@@ -144,18 +172,20 @@
 	lightSwitch.toggle()
 	//lightSwitch 现在的值为 .On
 
-
+
 ## 协议类型
 
-`协议`本身不实现任何功能,但你可以将它当做`类型`来使用.
+`协议`本身不实现任何功能，但你可以将它当做`类型`来使用。
 
-使用场景:
+使用场景：
 
-* 作为函数,方法或构造器中的参数类型,返回值类型
-* 作为常量,变量,属性的类型
-* 作为数组,字典或其他容器中的元素类型
+* 作为函数，方法或构造器中的参数类型，返回值类型
+* 作为常量，变量，属性的类型
+* 作为数组，字典或其他容器中的元素类型
 
-> 注意: 协议类型应与其他类型(Int,Double,String)的写法相同,使用驼峰式
+> 注意：
+>
+协议类型应与其他类型(Int，Double，String)的写法相同，使用驼峰式
 
 	class Dice {
 		let sides: Int
@@ -169,15 +199,15 @@
 		}
 	}
 
-这里定义了一个名为 `Dice`的类,用来代表桌游中的N个面的骰子.
+这里定义了一个名为 `Dice`的类，用来代表桌游中的N个面的骰子。
 
- `Dice`含有`sides`和`generator`两个属性,前者用来表示骰子有几个面,后者为骰子提供一个随机数生成器.由于后者为`RandomNumberGenerator`的协议类型.所以它能够被赋值为任意`遵循`该协议的类型.
+ `Dice`含有`sides`和`generator`两个属性，前者用来表示骰子有几个面，后者为骰子提供一个随机数生成器。由于后者为`RandomNumberGenerator`的协议类型。所以它能够被赋值为任意`遵循`该协议的类型。
 
-此外,使用`构造器(init)`来代替之前版本中的`setup`操作.构造器中含有一个名为`generator`,类型为`RandomNumberGenerator`的形参,使得它可以接收任意遵循`RandomNumberGenerator`协议的类型.
+此外，使用`构造器(init)`来代替之前版本中的`setup`操作。构造器中含有一个名为`generator`，类型为`RandomNumberGenerator`的形参，使得它可以接收任意遵循`RandomNumberGenerator`协议的类型。
 
-`roll`方法用来模拟骰子的面值.它先使用`generator`的`random`方法来创建一个[0-1]区间内的随机数种子,然后加工这个随机数种子生成骰子的面值.
+`roll`方法用来模拟骰子的面值。它先使用`generator`的`random`方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。
 
-如下所示,`LinearCongruentialGenerator`的实例作为随机数生成器传入`Dice`的`构造器`
+如下所示，`LinearCongruentialGenerator`的实例作为随机数生成器传入`Dice`的`构造器`
 
 	var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
 	for _ in 1...5 {
@@ -190,15 +220,16 @@
 	//Random dice roll is 5
 	//Random dice roll is 4
 
+
 ## 委托(代理)模式
 
-委托是一种设计模式(*译者注: 想起了那年 UITableViewDelegate 中的奔跑,那是我逝去的Objective-C...*),它允许`类`或`结构体`将一些需要它们负责的功能`交由(委托)`给其他的类型.
+委托是一种设计模式，它允许类或结构体将一些需要它们负责的功能`交由(委托)`给其他的类型。
 
-委托模式的实现很简单: 定义`协议`来`封装`那些需要被委托的`函数和方法`, 使其`遵循者`拥有这些被委托的`函数和方法`.
+委托模式的实现很简单： 定义`协议`来`封装`那些需要被委托的`函数和方法`， 使其`遵循者`拥有这些被委托的`函数和方法`。
 
-委托模式可以用来响应特定的动作或接收外部数据源提供的数据,而无需要知道外部数据源的类型.
+委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型。
 
-下文是两个基于骰子游戏的协议:
+下文是两个基于骰子游戏的协议：
 
 	protocol DiceGame {
 		var dice: Dice { get }
@@ -210,9 +241,9 @@
 		func gameDidEnd(game: DiceGame)
 	}
 
-`DiceGame`协议可以在任意含有骰子的游戏中实现,`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程
+`DiceGame`协议可以在任意含有骰子的游戏中实现，`DiceGameDelegate`协议可以用来追踪`DiceGame`的游戏过程。
 
-如下所示,`SnakesAndLadders`是`Snakes and Ladders`(译者注:[Control Flow](2)章节有该游戏的详细介绍)游戏的新版本.新版本使用`Dice`作为骰子,并且实现了`DiceGame`和`DiceGameDelegate`协议
+如下所示，`SnakesAndLadders`是`Snakes and Ladders`(译者注：[控制流](05_Control_Flow.html)章节有该游戏的详细介绍)游戏的新版本。新版本使用`Dice`作为骰子，并且实现了`DiceGame`和`DiceGameDelegate`协议
 
 	class SnakesAndLadders: DiceGame {
 		let finalSquare = 25
@@ -245,15 +276,17 @@
  		}
 	}
 
-游戏的`初始化设置(setup)`被为`SnakesAndLadders`类的`构造器(initializer)`实现.所有的游戏逻辑被转移到了`play`方法中.
+游戏的`初始化设置(setup)`被`SnakesAndLadders`类的`构造器(initializer)`实现。所有的游戏逻辑被转移到了`play`方法中。
 
-> 注意:因为`delegate`并不是该游戏的必备条件,`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性
+> 注意：
+>
+因为`delegate`并不是该游戏的必备条件，`delegate`被定义为遵循`DiceGameDelegate`协议的可选属性
 
-`DicegameDelegate`协议提供了三个方法用来追踪游戏过程.被放置于游戏的逻辑中,即`play()`方法内.分别在游戏开始时,新一轮开始时,游戏结束时被调用.
+`DicegameDelegate`协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即`play()`方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。
 
-因为`delegate`是一个遵循`DiceGameDelegate`的可选属性,因此在`play()`方法中使用了`可选链`来调用委托方法. 若`delegate`属性为`nil`, 则委托调用*优雅地*失效.若`delegate`不为`nil`,则委托方法被调用
+因为`delegate`是一个遵循`DiceGameDelegate`的可选属性，因此在`play()`方法中使用了`可选链`来调用委托方法。 若`delegate`属性为`nil`， 则委托调用*优雅地*失效。若`delegate`不为`nil`，则委托方法被调用
 
-如下所示,`DiceGameTracker`遵循了`DiceGameDelegate`协议
+如下所示，`DiceGameTracker`遵循了`DiceGameDelegate`协议
 
 	class DiceGameTracker: DiceGameDelegate {
     	var numberOfTurns = 0
@@ -273,11 +306,11 @@
     	}
 	}
 
-`DiceGameTracker`实现了`DiceGameDelegate`协议的方法要求,用来记录游戏已经进行的轮数. 当游戏开始时,`numberOfTurns`属性被赋值为0; 在每新一轮中递加; 游戏结束后,输出打印游戏的总轮数.
+`DiceGameTracker`实现了`DiceGameDelegate`协议的方法要求，用来记录游戏已经进行的轮数。 当游戏开始时，`numberOfTurns`属性被赋值为0；在每新一轮中递加；游戏结束后，输出打印游戏的总轮数。
 
-`gameDidStart`方法从`game`参数获取游戏信息并输出.`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型,所以方法中只能访问`DiceGame`协议中的成员.
+`gameDidStart`方法从`game`参数获取游戏信息并输出。`game`在方法中被当做`DiceGame`类型而不是`SnakeAndLadders`类型，所以方法中只能访问`DiceGame`协议中的成员。
 
-`DiceGameTracker`的运行情况,如下所示:
+`DiceGameTracker`的运行情况，如下所示：
 
 	“let tracker = DiceGameTracker()
 	let game = SnakesAndLadders()
@@ -291,13 +324,16 @@
 	// Rolled a 5
 	// The game lasted for 4 turns”
 
+
 ## 在扩展中添加协议成员
 
-即便无法修改源代码,依然可以通过`扩展(Extension)`来扩充已存在类型(*译者注: 类,结构体,枚举等*).`扩展`可以为已存在的类型添加`属性`,`方法`,`下标`,`协议`等成员.详情请在[扩展](4)章节中查看.
+即便无法修改源代码，依然可以通过`扩展(Extension)`来扩充已存在类型(*译者注： 类，结构体，枚举等*)。`扩展`可以为已存在的类型添加`属性`，`方法`，`下标`，`协议`等成员。详情请在[扩展](20_Extensions.html)章节中查看。
 
-> 注意: 通过`扩展`为已存在的类型`遵循`协议时,该类型的所有实例也会随之添加协议中的方法
+> 注意：
+>
+通过`扩展`为已存在的类型`遵循`协议时，该类型的所有实例也会随之添加协议中的方法
 
-`TextRepresentable`协议含有一个`asText`,如下所示:
+`TextRepresentable`协议含有一个`asText`，如下所示：
 
 	protocol TextRepresentable {
 		func asText() -> String
@@ -311,13 +347,13 @@
 		}
 	}
 
-从现在起,`Dice`类型的实例可被当作`TextRepresentable`类型:
+从现在起，`Dice`类型的实例可被当作`TextRepresentable`类型：
 
 	let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
 	println(d12.asText())
 	// 输出 "A 12-sided dice"
 
-`SnakesAndLadders`类也可以通过`扩展`的方式来遵循协议:
+`SnakesAndLadders`类也可以通过`扩展`的方式来遵循协议：
 
 	extension SnakeAndLadders: TextRepresentable {
 		func asText() -> String {
@@ -327,9 +363,10 @@
 	println(game.asText())
 	// 输出 "A game of Snakes and Ladders with 25 squares"
 
+
 ## 通过延展补充协议声明
 
-当一个类型已经实现了协议中的所有要求,却没有声明时,可以通过`扩展`来补充协议声明:
+当一个类型已经实现了协议中的所有要求，却没有声明时，可以通过`扩展`来补充协议声明：
 
 	struct Hamster {
 		var name: String
@@ -339,22 +376,25 @@
 	}
 	extension Hamster: TextRepresentabl {}
 
-从现在起,`Hamster`的实例可以作为`TextRepresentable`类型使用
+从现在起，`Hamster`的实例可以作为`TextRepresentable`类型使用
 
 	let simonTheHamster = Hamster(name: "Simon")
 	let somethingTextRepresentable: TextRepresentabl = simonTheHamester
 	println(somethingTextRepresentable.asText())
 	// 输出 "A hamster named Simon"
 
-> 注意: 即时满足了协议的所有要求,类型也不会自动转变,因此你必须为它做出明显的协议声明
+> 注意：
+>
+即时满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明
 
+
 ## 集合中的协议类型
 
-协议类型可以被集合使用,表示集合中的元素均为协议类型:
+协议类型可以被集合使用，表示集合中的元素均为协议类型：
 
 	let things: TextRepresentable[] = [game,d12,simoTheHamster]
 
-如下所示,`things`数组可以被直接遍历,并调用其中元素的`asText()`函数:
+如下所示，`things`数组可以被直接遍历，并调用其中元素的`asText()`函数：
 
 	for thing in things {
 		println(thing.asText())
@@ -363,25 +403,26 @@
 	// A 12-sided dice
 	// A hamster named Simon
 
-`thing`被当做是`TextRepresentable`类型而不是`Dice`,`DiceGame`,`Hamster`等类型.因此能且仅能调用`asText`方法
+`thing`被当做是`TextRepresentable`类型而不是`Dice`，`DiceGame`，`Hamster`等类型。因此能且仅能调用`asText`方法
 
+
 ## 协议的继承
 
-协议能够继承一到多个其他协议.语法与类的继承相似,多个协议间用逗号`,`分隔
+协议能够*继承*一到多个其他协议。语法与类的继承相似，多个协议间用逗号`,`分隔
 
 	protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
 		// 协议定义
 	}
 
-如下所示,`PrettyTextRepresentable`协议继承了`TextRepresentable`协议
+如下所示，`PrettyTextRepresentable`协议继承了`TextRepresentable`协议
 
 	protocol PrettyTextRepresentable: TextRepresentable {
 		func asPrettyText() -> String
 	}
 
-`遵循``PrettyTextRepresentable`协议的同时,也需要`遵循`TextRepresentable`协议.
+`遵循``PrettyTextRepresentable`协议的同时，也需要`遵循`TextRepresentable`协议。
 
-如下所示,用`扩展`为`SnakesAndLadders`遵循`PrettyTextRepresentable`协议:
+如下所示，用`扩展`为`SnakesAndLadders`遵循`PrettyTextRepresentable`协议：
 
 	extension SnakesAndLadders: PrettyTextRepresentable {
     	func asPrettyText() -> String {
@@ -400,26 +441,27 @@
     	}
 	}
 
-在`for in`中迭代出了`board`数组中的每一个元素:
+在`for in`中迭代出了`board`数组中的每一个元素：
 
-* 当从数组中迭代出的元素的值大于0时,用`▲`表示
-* 当从数组中迭代出的元素的值小于0时,用`▼`表示
-* 当从数组中迭代出的元素的值等于0时,用`○`表示
+* 当从数组中迭代出的元素的值大于0时，用`▲`表示
+* 当从数组中迭代出的元素的值小于0时，用`▼`表示
+* 当从数组中迭代出的元素的值等于0时，用`○`表示
 
-任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法.
+任意`SankesAndLadders`的实例都可以使用`asPrettyText()`方法。
 
 	println(game.asPrettyText())
 	// A game of Snakes and Ladders with 25 squares:
 	// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
 
+
 ## 协议合成
 
-一个协议可由多个协议采用`protocol`这样的格式进行组合,称为`协议合成(protocol composition)`.
+一个协议可由多个协议采用`protocol`这样的格式进行组合，称为`协议合成(protocol composition)`。
 
-举个栗子:
+举个例子：
 
 	protocol Named {
-    var name: String { get }
+    	var name: String { get }
 	}
 	protocol Aged {
 	    var age: Int { get }
@@ -429,37 +471,44 @@
     	var age: Int
 	}
 	func wishHappyBirthday(celebrator: protocol) {
-    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
+    	println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
 	}
 	let birthdayPerson = Person(name: "Malcolm", age: 21)
 	wishHappyBirthday(birthdayPerson)
 	// 输出 "Happy birthday Malcolm - you're 21!
 
-`Named`协议包含`String`类型的`name`属性;`Aged`协议包含`Int`类型的`age`属性.`Person`结构体`遵循`了这两个协议.
+`Named`协议包含`String`类型的`name`属性；`Aged`协议包含`Int`类型的`age`属性。`Person`结构体`遵循`了这两个协议。
 
-`wishHappyBirthday`函数的形参`celebrator`的类型为`protocol`.可以传入任意`遵循`这两个协议的类型的实例
+`wishHappyBirthday`函数的形参`celebrator`的类型为`protocol`。可以传入任意`遵循`这两个协议的类型的实例
 
-> 注意: `协议合成`并不会生成一个新协议类型,而是将多个协议合成为一个临时的协议,超出范围后立即失效.
+> 注意：
+>
+`协议合成`并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。
 
+
 ## 检验协议的一致性
 
-使用`is`检验协议一致性,使用`as`将协议类型`向下转换(downcast)`为的其他协议类型.检验与转换的语法和之前相同(*详情查看[Typy Casting章节](5)*):
+使用`is`检验协议一致性，使用`as`将协议类型`向下转换(downcast)`为的其他协议类型。检验与转换的语法和之前相同(*详情查看[类型检查](18_Type_Casting.html)*)：
 
-* `is`操作符用来检查实例是否`遵循`了某个`协议`.
-* `as?`返回一个可选值,当实例`遵循`协议时,返回该协议类型;否则返回`nil`
-* `as`用以强制向下转型.
+* `is`操作符用来检查实例是否`遵循`了某个`协议`。
+* `as?`返回一个可选值，当实例`遵循`协议时，返回该协议类型；否则返回`nil`
+* `as`用以强制向下转换型。
 
-	@objc protocol HasArea {
-		var area: Double { get }
-	}
+```
+@objc protocol HasArea {
+	var area: Double { get }
+}
+```
 
 
-> 注意: `@objc`用来表示协议是可选的,也可以用来表示暴露给`Objective-C`的代码,此外,`@objc`型协议只对`类`有效,因此只能在`类`中检查协议的一致性.详情查看*[Using Siwft with Cocoa and Objectivei-c](6)*.
+> 注意：
+>
+`@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)*。
 
 	class Circle: HasArea {
     	let pi = 3.1415927
     	var radius: Double
-    	var area: Double { return pi * radius * radius }
+    	var area:≈radius }
     	init(radius: Double) { self.radius = radius }
 	}
 	class Country: HasArea {
@@ -467,16 +516,16 @@
     	init(area: Double) { self.area = area }
 	}
 
-`Circle`和`Country`都遵循了`HasArea`协议,前者把`area`写为`计算型属性`,后者则把`area`写为`存储型属性`
+`Circle`和`Country`都遵循了`HasArea`协议，前者把`area`写为计算型属性（computed property），后者则把`area`写为存储型属性（stored property）。
 
-如下所示,Animal类没有实现任何协议
+如下所示，`Animal`类没有实现任何协议
 
 	class Animal {
 		var legs: Int
 		init(legs: Int) { self.legs = legs }
 	}
 
-`Circle,Country,Animal`并没有一个相同的基类,所以采用`AnyObject`类型的数组来装载在他们的实例,如下所示:
+`Circle,Country,Animal`并没有一个相同的基类，所以采用`AnyObject`类型的数组来装载在他们的实例，如下所示：
 
 	let objects: AnyObject[] = [
 		Circle(radius: 2.0),
@@ -484,7 +533,7 @@
 		Animal(legs: 4)
 	]
 
-如下所示,在迭代时检查`object`数组的元素是否`遵循`了`HasArea`协议:
+如下所示，在迭代时检查`object`数组的元素是否`遵循`了`HasArea`协议：
 
 	for object in objects {
 	    if let objectWithArea = object as? HasArea {
@@ -497,32 +546,37 @@
 	// Area is 243610.0
 	// Something that doesn't have an area
 
-当数组中的元素遵循`HasArea`协议时,通过`as?`操作符将其`可选绑定(optional binding)`到`objectWithArea`常量上.
+当数组中的元素遵循`HasArea`协议时，通过`as?`操作符将其`可选绑定(optional binding)`到`objectWithArea`常量上。
 
-`objects`数组中元素的类型并不会因为`向下转型`而改变,当它们被赋值给`objectWithArea`时只被视为`HasArea`类型,因此只有`area`属性能够被访问.
+`objects`数组中元素的类型并不会因为`向下转型`而改变，当它们被赋值给`objectWithArea`时只被视为`HasArea`类型，因此只有`area`属性能够被访问。
 
+
 ## 可选协议要求
 
-可选协议含有可选成员,其`遵循者`可以选择是否实现这些成员.在协议中使用`@optional`关键字作为前缀来定义可选成员.
+可选协议含有可选成员，其`遵循者`可以选择是否实现这些成员。在协议中使用`@optional`关键字作为前缀来定义可选成员。
 
-可选协议在调用时使用`可选链`,详细内容在[Optional Chaning](7)章节中查看.
+可选协议在调用时使用`可选链`，详细内容在[可选链](17_Optional_Chaining.html)章节中查看。
 
-像`someOptionalMethod?(someArgument)`一样,你可以在可选方法名称后加上`?`来检查该方法是否被实现.`可选方法`和`可选属性`都会返回一个`可选值(optional value)`,当其不可访问时,`?`之后语句不会执行,并返回`nil`
+像`someOptionalMethod?(someArgument)`一样，你可以在可选方法名称后加上`?`来检查该方法是否被实现。`可选方法`和`可选属性`都会返回一个`可选值(optional value)`，当其不可访问时，`?`之后语句不会执行，并返回`nil`。
 
-> 注意: 可选协议只能在含有`@objc`前缀的协议中生效.且`@objc`的协议只能被`类`遵循
+> 注意：
+>
+可选协议只能在含有`@objc`前缀的协议中生效。且`@objc`的协议只能被`类`遵循。
 
-`Counter`类使用`CounterDataSource`类型的外部数据源来提供`增量值(increment amount)`,如下所示:
+`Counter`类使用`CounterDataSource`类型的外部数据源来提供`增量值(increment amount)`，如下所示：
 
 	@objc protocol CounterDataSource {
     	@optional func incrementForCount(count: Int) -> Int
     	@optional var fixedIncrement: Int { get }
 	}
 
-`CounterDataSource`含有`incrementForCount`的`可选方法`和`fiexdIncrement`的`可选属性`.
+`CounterDataSource`含有`incrementForCount`的`可选方法`和`fiexdIncrement`的`可选属性`。
 
-> 注意: `CounterDataSource`中的属性和方法都是可选的,因此可以在类中声明但不实现这些成员,尽管技术上允许这样做,不过最好不要这样写.
+> 注意：
+>
+`CounterDataSource`中的属性和方法都是可选的，因此可以在类中声明但不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。
 
-`Counter`类含有`CounterDataSource?`类型的可选属性`dataSource`,如下所示:
+`Counter`类含有`CounterDataSource?`类型的可选属性`dataSource`，如下所示：
 
 	@objc class Counter {
 	    var count = 0
@@ -536,24 +590,24 @@
 	    }
 	}
 
-`count`属性用于存储当前的值,`increment`方法用来为`count`赋值.
+`count`属性用于存储当前的值，`increment`方法用来为`count`赋值。
 
-`increment`方法通过`可选链`,尝试从两种`可选成员`中获取`count`.
+`increment`方法通过`可选链`，尝试从两种`可选成员`中获取`count`。
 
-1. 由于`dataSource`可能为`nil`,因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用incrementForCount`方法.
-2. 即使`dataSource`存在,但是也无法保证其是否实现了`incrementForCount`方法,因此在`incrementForCount`方法后边也加有`?`标记
+1. 由于`dataSource`可能为`nil`，因此在`dataSource`后边加上了`?`标记来表明只在`dataSource`非空时才去调用incrementForCount`方法。
+2. 即使`dataSource`存在，但是也无法保证其是否实现了`incrementForCount`方法，因此在`incrementForCount`方法后边也加有`?`标记。
 
-在调用`incrementForCount`方法后,`Int`型`可选值`通过`可选绑定(optional binding)`自动拆包并赋值给常量`amount`.
+在调用`incrementForCount`方法后，`Int`型`可选值`通过`可选绑定(optional binding)`自动拆包并赋值给常量`amount`。
 
-当`incrementForCount`不能被调用时,尝试使用`可选属性``fixedIncrement`来代替.
+当`incrementForCount`不能被调用时，尝试使用`可选属性``fixedIncrement`来代替。
 
-`ThreeSource`实现了`CounterDataSource`协议,如下所示:
+`ThreeSource`实现了`CounterDataSource`协议，如下所示：
 
 	class ThreeSource: CounterDataSource {
 		let fixedIncrement = 3
 	}
 
-使用`ThreeSource`作为数据源开实例化一个`Counter`:
+使用`ThreeSource`作为数据源开实例化一个`Counter`：
 
 	var counter = Counter()
 	counter.dataSource = ThreeSource()
@@ -566,7 +620,7 @@
 	// 9
 	// 12
 
-`TowardsZeroSource`实现了`CounterDataSource`协议中的`incrementForCount`方法,如下所示:
+`TowardsZeroSource`实现了`CounterDataSource`协议中的`incrementForCount`方法，如下所示：
 
 	class TowardsZeroSource: CounterDataSource {
     func incrementForCount(count: Int) -> Int {
@@ -580,7 +634,7 @@
     	}
 	}
 
-下边是执行的代码:
+下边是执行的代码：
 
 	counter.count = -4
 	counter.dataSource = TowardsZeroSource()
@@ -593,14 +647,3 @@
 	// -1
 	// 0
 	// 0
-
-
-
-[1]:http://baidu.com
-[2]:http://baidu.com
-[3]:http://baidu.com
-[4]:http://baidu.com
-[5]:http://baidu.com
-[6]:http://baidu.com
-[7]:http://baidu.com
-
diff --git a/source/chapter2/22_Generics.md b/source/chapter2/22_Generics.md
index 3b779aac..e2be186a 100644
--- a/source/chapter2/22_Generics.md
+++ b/source/chapter2/22_Generics.md
@@ -1,140 +1,137 @@
+> 翻译：takalard
+
+> 校对：lifedim
+
 # 泛型
 
 ------
+
 本页包含内容：
 
--   泛型所解决的问题
--   泛型函数
--   类型参数
--   命名类型参数
--   泛型类型
--   类型约束
--   关联类型
--   Where语句
+- [泛型所解决的问题](#the_problem_that_generics_solve)
+- [泛型函数](#generic_functions)
+- [类型参数](#type_parameters)
+- [命名类型参数](#naming_type_parameters)
+- [泛型类型](#generic_types)
+- [类型约束](#type_constraints)
+- [关联类型](#associated_types)
+- [`Where`语句](#where_clauses)
 
-*泛型代码*可以确保你写出灵活的，可重用的函数和定义出任何你所确定好的需求的类型。你的可以写出避免重复的代码，并且用一种清晰的，抽象的方式表达出来。
+*泛型代码*可以让你写出根据自我需求定义、适用于任何类型的，灵活且可重用的函数和类型。它的可以让你避免重复的代码，用一种清晰和抽象的方式来表达代码的意图。
 
-泛型是Swift需要强大特征中的其中一个，许多Swift标准库是通过泛型代码构建出来的。事实上，你已经使用泛型贯穿着整个Language Guide，即便你没有实现它。例如：Swift的Array和Dictionary类型都是泛型集。你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他Swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(dictionary)，而且这些类型可以是没有限制的。
-
-------
+泛型是 Swift 强大特征中的其中一个，许多 Swift 标准库是通过泛型代码构建出来的。事实上，泛型的使用贯穿了整本语言手册，只是你没有发现而已。例如，Swift 的数组和字典类型都是泛型集。你可以创建一个`Int`数组，也可创建一个`String`数组，或者甚至于可以是任何其他 Swift 的类型数据数组。同样的，你也可以创建存储任何指定类型的字典（dictionary），而且这些类型可以是没有限制的。
 
+
 ## 泛型所解决的问题
 
-这里是一个标准的，非泛型函数swapTwoInts,用来交换两个Int值：
+这里是一个标准的，非泛型函数`swapTwoInts`,用来交换两个Int值：
 
-```C
-	func swapTwoInts(inout a: Int, inout b: Int) 
+	func swapTwoInts(inout a: Int, inout b: Int)
 		let temporaryA = a
 		a = b
 		b = temporaryA
 	}
-```
-这个函数使用in-out参数交换a和b的值，这两个参数被描述为[In-Out类型参数][1]。
 
-`swapTwoInts`函数可以交换b的原始值到a，也可以交换a的原始值到b，你可以调用这个函数交换两个Int变量值：
-```C
+这个函数使用写入读出（in-out）参数来交换`a`和`b`的值，请参考[写入读出参数][1]。
+
+`swapTwoInts`函数可以交换`b`的原始值到`a`，也可以交换a的原始值到`b`，你可以调用这个函数交换两个`Int`变量值：
+
     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"
-```
+    // 输出 "someInt is now 107, and anotherInt is now 3"
 
-`swapTwoInts`函数是非常有用的，但是它只能交换Int值，如果你想要交换两个String或者Double，就不得不写更多的函数，如 `swapTwoStrings`和`swapTwoDoublesfunctions `，如同如下所示：
 
-```C
+`swapTwoInts`函数是非常有用的，但是它只能交换`Int`值，如果你想要交换两个`String`或者`Double`，就不得不写更多的函数，如 `swapTwoStrings`和`swapTwoDoublesfunctions `，如同如下所示：
+
     func swapTwoStrings(inout a: String, inout b: String) {
         let temporaryA = a
         a = b
         b = temporaryA
     }
-     
+
     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`。
 
 但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）
 
->NOTE
-
->In all three functions, it is important that the types of a and b are defined to be the same as each other. If a and b were not of the same type, it would not be possible to swap their values. Swift is a type-safe language, and does not allow (for example) a variable of type String and a variable of type Double to swap values with each other. Attempting to do so would be reported as a compile-time error.
-
+>注意：
+在所有三个函数中，`a`和`b`的类型是一样的。如果`a`和`b`不是相同的类型，那它们俩就不能互换值。Swift 是类型安全的语言，所以它不允许一个`String`类型的变量和一个`Double`类型的变量互相交换值。如果一定要做，Swift 将报编译错误。
 
+
 ## 泛型函数
 
-`泛型函数`可以工作于任何类型，这里是一个上面`swapTwoInts`函数的泛型版本，用于交换两个值： 
-```C
+`泛型函数`可以工作于任何类型，这里是一个上面`swapTwoInts`函数的泛型版本，用于交换两个值：
+
     func swapTwoValues(inout a: T, inout b: T) {
         let temporaryA = a
         a = b
         b = temporaryA
     }
-```
-`swapTwoValues`函数主体和`swapTwoInts`函数是一样，而且，只在第一行稍微有那么一点点不同于`swapTwoInts`，如下所示：
-```C
+
+`swapTwoValues`函数主体和`swapTwoInts`函数是一样的，它只在第一行稍微有那么一点点不同于`swapTwoInts`，如下所示：
+
     func swapTwoInts(inout a: Int, inout b: Int)
     func swapTwoValues(inout a: T, inout b: T)
-```
 
-这个函数的泛型版本使用了节点类型命名（通常此情况下用字母T来表示）来代替实际类型名（如Int、String或Double）。节点类型名并不是表示T必须是任何类型，但是其规定a和b必须是同一类型的T，而不管T表示任何类型。只有`swapTwoValues`函数在每次调用时所传入的实际类型决定了T所代表的类型。
 
-另外一个不同之处在于这个泛型函数名后面跟着的节点类型名(T)是用尖括号括起来的()。这个尖括号告诉Swift那个T是`swapTwoValues`函数所定义的一个节点类型。因为T是一个节点，Swift不会去查找每一个命名为T的实际类型。
+这个函数的泛型版本使用了占位类型名字（通常此情况下用字母`T`来表示）来代替实际类型名（如`In`、`String`或`Doubl`）。占位类型名没有提示`T`必须是什么类型，但是它提示了`a`和`b`必须是同一类型`T`，而不管`T`表示什么类型。只有`swapTwoValues`函数在每次调用时所传入的实际类型才能决定`T`所代表的类型。
 
-`swapTwoValues`函数除了只要传入的两个任何类型值是同一类型外，也可以作为`swapTwoInts`函数被调用。每次`swapTwoValues`被调用，T所代表的类型值都会传给函数。
+另外一个不同之处在于这个泛型函数名后面跟着的展位类型名字（T）是用尖括号括起来的（）。这个尖括号告诉 Swift 那个`T`是`swapTwoValues`函数所定义的一个类型。因为`T`是一个占位命名类型，Swift 不会去查找命名为T的实际类型。
 
-在下面的两个例子中,T分别代表Tnt和String：
+`swapTwoValues`函数除了要求传入的两个任何类型值是同一类型外，也可以作为`swapTwoInts`函数被调用。每次`swapTwoValues`被调用，T所代表的类型值都会传给函数。
+
+在下面的两个例子中,`T`分别代表`Int`和`String`：
 
-```C
     var someInt = 3
     var anotherInt = 107
     swapTwoValues(&someInt, &anotherInt)
     // someInt is now 107, and anotherInt is now 3
-     
+
     var someString = "hello"
     var anotherString = "world"
     swapTwoValues(&someString, &anotherString)
     // someString is now "world", and anotherString is now "hello"
 
-```
 
->NOTE
+>注意
+上面定义的函数`swapTwoValues`是受`swap`函数启发而实现的。`swap`函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似`swapTwoValues`函数的功能，你可以使用已存在的交换函数`swap`函数。
 
->The swapTwoValues function defined above is inspired by a generic function called swap, which is part of the Swift standard library, and is automatically made available for you to use in your apps. If you need the behavior of the swapTwoValues function in your own code, you can use Swift’s existing swap function rather than providing your own implementation.
-
-##Type Parameters
+
 ## 类型参数
 
-在上面的`swapTwoValues`例子中，节点类型T是一种类型参数的示例。类型参数指定并命名为一个节点类型，并且紧随在函数名后面，并用一对尖括号括起来（如）。
+在上面的`swapTwoValues`例子中，占位类型`T`是一种类型参数的示例。类型参数指定并命名为一个占位类型，并且紧随在函数名后面，使用一对尖括号括起来（如）。
 
-一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如`swapTwoValues`函数中的参数a和b），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的节点类型不管函数任何时候被调用，都会被实际类型所替换（在上面`swapTwoValues`例子中，当函数第一次被调用时，T被Int替换，第二次调用时，被String替换。）。
+一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如`swapTwoValues`函数中的参数`a`和`b`），或作为一个函数返回类型，或用作函数主体中的注释类型。在这种情况下，被类型参数所代表的占位类型不管函数任何时候被调用，都会被实际类型所替换（在上面`swapTwoValues`例子中，当函数第一次被调用时，`T`被`Int`替换，第二次调用时，被`String`替换。）。
 
 你可支持多个类型参数，命名在尖括号中，用逗号分开。
 
+
 ## 命名类型参数
 
-在简单的情况下，泛型函数或泛型类型需要指定一个节点类型（如上面的`swapTwoValues`泛型函数，或一个存储单一类型的泛型集，如Array），通常用一单个字母T来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
+在简单的情况下，泛型函数或泛型类型需要指定一个占位类型（如上面的`swapTwoValues`泛型函数，或一个存储单一类型的泛型集，如数组），通常用一单个字母`T`来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。
 
-如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift字典(Dictionary)类型有两个类型参数，一个是key，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为KeyType和ValueType，用来记住它们在你的泛型代码中的作用。
+如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为`KeyType`和`ValueType`，用来记住它们在你的泛型代码中的作用。
 
->NOTE
-
->Always give type parameters UpperCamelCase names (such as T and KeyType) to indicate that they are a placeholder for a type, not a value.
+>注意
+请始终使用大写字母开头的驼峰式命名法（例如`T`和`KeyType`）来给类型参数命名，以表明它们是类型的占位符，而非类型值。
 
+
 ## 泛型类型
 
 
-通常在泛型函数中，Swift允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同`Array`和`Dictionary`的用法。
+通常在泛型函数中，Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同`Array`和`Dictionary`的用法。
 
-这部分向你展示如何写一个泛型集类型-`Stack`(栈)。一个栈是一系列值域的集合，和array(数组)相似，但其是一个比Swift的`Array`类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许，只允许在集合的末端添加新的项（如同*push*一个新值进栈）。同样的一个栈也只能从末端移除项（如同*pop*一个值出栈）。
+这部分向你展示如何写一个泛型集类型--`Stack`（栈）。一个栈是一系列值域的集合，和`Array`（数组）类似，但其是一个比 Swift 的`Array`类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同*push*一个新值进栈）。同样的一个栈也只能从末端移除项（如同*pop*一个值出栈）。
 
->NOTE
-
->The concept of a stack is used by the UINavigationController class to model the view controllers in its navigation hierarchy. You call the UINavigationController class pushViewController:animated: method to add (or push) a view controller on to the navigation stack, and its popViewControllerAnimated: method to remove (or pop) a view controller from the navigation stack. A stack is a useful collection model whenever you need a strict “last in, first out” approach to managing a collection.
+>注意
+栈的概念已被`UINavigationController`类使用来模拟试图控制器的导航结构。你通过调用`UINavigationController`的`pushViewController:animated:`方法来为导航栈添加（add）新的试图控制器；而通过`popViewControllerAnimated:`的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的`后进先出`方式来管理集合，堆栈都是最实用的模型。
 
 下图展示了一个栈的压栈(push)/出栈(pop)的行为：
 
@@ -147,17 +144,16 @@
 5. 移除掉一个值后，现在栈又重新只有三个值。
 
 这里展示了如何写一个非泛型版本的栈，`Int`值型的栈：
-```C
-struct IntStack {
-    var items = Int[]()
-    mutating func push(item: Int) {
-        items.append(item)
-    }
-    mutating func pop() -> Int {
-        return items.removeLast()
-    }
-}
-```
+
+	struct IntStack {
+	    var items = Int[]()
+	    mutating func push(item: Int) {
+	        items.append(item)
+	    }
+	    mutating func pop() -> Int {
+	        return items.removeLast()
+	    }
+	}
 
 这个结构体在栈中使用一个`Array`性质的`items`存储值。`Stack`提供两个方法：`push`和`pop`，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为他们需要修改（或*转换*）结构体的`items`数组。
 
@@ -165,135 +161,131 @@ struct IntStack {
 
 这里是一个相同代码的泛型版本：
 
-```C
-struct Stack {
-    var items = T[]()
-    mutating func push(item: T) {
-        items.append(item)
-    }
-    mutating func pop() -> T {
-        return items.removeLast()
-    }
-}
-```
 
-注意到`Stack`的泛型版本基本上和非泛型版本相同，但是泛型版本的节点类型参数为T代替了实际`Int`类型。这种类型参数包含在一对尖括号里(``)，紧随在结构体名字后面。
+	struct Stack {
+	    var items = T[]()
+	    mutating func push(item: T) {
+	        items.append(item)
+	    }
+	    mutating func pop() -> T {
+	        return items.removeLast()
+	    }
+	}
 
-T定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，T在如下三个地方被用作节点：
+
+注意到`Stack`的泛型版本基本上和非泛型版本相同，但是泛型版本的占位类型参数为T代替了实际`Int`类型。这种类型参数包含在一对尖括号里（``），紧随在结构体名字后面。
+
+`T`定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，`T`在如下三个地方被用作节点：
 
 - 创建一个名为`items`的属性，使用空的T类型值数组对其进行初始化；
 - 指定一个包含一个参数名为`item`的`push`方法，该参数必须是T类型；
 - 指定一个`pop`方法的返回值，该返回值将是一个T类型值。
 
 当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个`Stack`实例，同创建`Array`和`Dictionary`一样：
-```c
-var stackOfStrings = Stack()
-stackOfStrings.push("uno")
-stackOfStrings.push("dos")
-stackOfStrings.push("tres")
-stackOfStrings.push("cuatro")
-// 现在栈已经有4个string了
-```
-下图将展示`stackOfStrings`如何push这四个值进栈的过程：
+
+	var stackOfStrings = Stack()
+	stackOfStrings.push("uno")
+	stackOfStrings.push("dos")
+	stackOfStrings.push("tres")
+	stackOfStrings.push("cuatro")
+	// 现在栈已经有4个string了
+
+下图将展示`stackOfStrings`如何`push`这四个值进栈的过程：
 
 ![此处输入图片的描述][3]
 
-从栈中pop并移除值"cuatro"：
+从栈中`pop`并移除值"cuatro"：
+
+	let fromTheTop = stackOfStrings.pop()
+	// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
 
-```C
-let fromTheTop = stackOfStrings.pop()
-// fromTheTop is equal to "cuatro", and the stack now contains 3 strings
-```
 下图展示了如何从栈中pop一个值的过程：
 ![此处输入图片的描述][4]
 
-由于`Stack`是泛型类型，所以在Swift中其可以用来创建任何有效类型的栈，这种方式如同`Array`和`Dictionary`。
+由于`Stack`是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同`Array`和`Dictionary`。
 
+
 ##类型约束
 
 `swapTwoValues`函数和`Stack`类型可以作用于任何类型，不过，有的时候对使用在泛型函数和泛型类型上的类型强制约束为某种特定类型是非常有用的。类型约束指定了一个必须继承自指定类的类型参数，或者遵循一个特定的协议或协议构成。
 
-例如，Swift的`Dictionary`类型对作用于其keys的类型做了些限制。在[Dictionaries][5]的描述中，字典的keys类型必须是*hashable*，也就是说，必须有一种方法可以使其是唯一的表示。`Dictionary`之所以需要其keys是hashable是为了以便于其检查其是否包含某个特定key的值。如无此需求，`Dictionary`即不会告诉是否插入或者替换了某个特定key的值，也不能查找到已经存储在字典里面的给定key值。
+例如，Swift 的`Dictionary`类型对作用于其键的类型做了些限制。在[字典][5]的描述中，字典的键类型必须是*可哈希*，也就是说，必须有一种方法可以使其是唯一的表示。`Dictionary`之所以需要其键是可哈希是为了以便于其检查其是否包含某个特定键的值。如无此需求，`Dictionary`即不会告诉是否插入或者替换了某个特定键的值，也不能查找到已经存储在字典里面的给定键值。
 
-这个需求强制加上一个类型约束作用于`Dictionary`的key上，当然其key类型必须遵循`Hashable`协议（Swift标准库中定义的一个特定协议）。所有的Swift基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是hashable。
+这个需求强制加上一个类型约束作用于`Dictionary`的键上，当然其键类型必须遵循`Hashable`协议（Swift 标准库中定义的一个特定协议）。所有的 Swift 基本类型（如`String`，`Int`， `Double`和 `Bool`）默认都是可哈希。
 
-当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如`Hashtable`具有的类型特征是根据他们概念特征来界定的，而不是他们的直接类型特征。
+当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如`可哈希`具有的类型特征是根据他们概念特征来界定的，而不是他们的直接类型特征。
 
 ### 类型约束语法
 
 你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：
-```c
-func someFunction(someT: T, someU: U) {
-    // function body goes here
-}
-```
+
+	func someFunction(someT: T, someU: U) {
+	    // function body goes here
+	}
 
 上面这个假定函数有两个类型参数。第一个类型参数`T`，有一个需要`T`必须是`SomeClass`子类的类型约束；第二个类型参数`U`，有一个需要`U`必须遵循`SomeProtocol`协议的类型约束。
 
 ### 类型约束行为
 
 这里有个名为`findStringIndex`的非泛型函数，该函数功能是去查找包含一给定`String`值的数组。若查找到匹配的字符串，`findStringIndex`函数返回该字符串在数组中的索引值（`Int`），反之则返回`nil`：
-```c
-func findStringIndex(array: String[], valueToFind: String) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
-        }
-    }
-    return nil
-}
-```
+
+	func findStringIndex(array: String[], valueToFind: String) -> Int? {
+	    for (index, value) in enumerate(array) {
+	        if value == valueToFind {
+	            return index
+	        }
+	    }
+	    return nil
+	}
+
 
 `findStringIndex`函数可以作用于查找一字符串数组中的某个字符串:
-```c
-let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
-if let foundIndex = findStringIndex(strings, "llama") {
-    println("The index of llama is \(foundIndex)")
-}
-// prints "The index of llama is 2"
-```
+
+	let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
+	if let foundIndex = findStringIndex(strings, "llama") {
+	    println("The index of llama is \(foundIndex)")
+	}
+	// 输出 "The index of llama is 2"
 
 如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数`findIndex`，用某个类型`T`值替换掉提到的字符串。
 
 这里展示如何写一个你或许期望的`findStringIndex`的泛型版本`findIndex`。请注意这个函数仍然返回`Int`，是不是有点迷惑呢，而不是泛型类型?那是因为函数返回的是一个可选的索引数，而不是从数组中得到的一个可选值。需要提醒的是，这个函数不会编译，原因在例子后面会说明：
 
-```c
-func findIndex(array: T[], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
-        }
-    }
-    return nil
-}
-```
+	func findIndex(array: T[], valueToFind: T) -> Int? {
+	    for (index, value) in enumerate(array) {
+	        if value == valueToFind {
+	            return index
+	        }
+	    }
+	    return nil
+	}
 
-上面所写的函数不会编译。这个问题的位置在等式的检查上，`“if value == valueToFind”`。不是所有的Swift中的类型都可以用等式符(==)进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么Swift没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型`T`，当你试图编译这部分代码时估计会出现相应的错误。
+上面所写的函数不会编译。这个问题的位置在等式的检查上，`“if value == valueToFind”`。不是所有的 Swift 中的类型都可以用等式符（==）进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么 Swift 没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型`T`，当你试图编译这部分代码时估计会出现相应的错误。
 
-不过，所有的这些并不会让我们无从下手。Swift标准库中定义了一个`Equatable`协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持`Equatable`协议。
+不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个`Equatable`协议，该协议要求任何遵循的类型实现等式符（==）和不等符（!=）对任何两个该类型进行比较。所有的 Swift 标准类型自动支持`Equatable`协议。
 
 任何`Equatable`类型都可以安全的使用在`findIndex`函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个`Equatable`类型约束作为类型参数定义的一部分：
-```c
-func findIndex(array: T[], valueToFind: T) -> Int? {
-    for (index, value) in enumerate(array) {
-        if value == valueToFind {
-            return index
-        }
-    }
-    return nil
-}
-```
+
+	func findIndex(array: T[], valueToFind: T) -> Int? {
+	    for (index, value) in enumerate(array) {
+	        if value == valueToFind {
+	            return index
+	        }
+	    }
+	    return nil
+	}
+
 
 `findIndex`中这个单个类型参数写做：`T: Equatable`，也就意味着“任何T类型都遵循`Equatable`协议”。
 
-findIndex函数现在则可以成功的编译过，并且作用于任何遵循Equatable的类型，如Double或String:
-```c
-let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
-// doubleIndex is an optional Int with no value, because 9.3 is not in the array
-let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
-// stringIndex is an optional Int containing a value of 2
-```
+`findIndex`函数现在则可以成功的编译过，并且作用于任何遵循`Equatable`的类型，如`Double`或`String`:
 
+	let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
+	// doubleIndex is an optional Int with no value, because 9.3 is not in the array
+	let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
+	// stringIndex is an optional Int containing a value of 2
+
+
 ##关联类型
 
 当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名（或*别名*）。作用于关联类型上实际类型是不需要指定的，直到该协议接受。关联类型被指定为`typealias`关键字。
@@ -301,14 +293,14 @@ let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
 ### 关联类型行为
 
 这里是一个`Container`协议的例子，定义了一个ItemType关联类型：
-```c
-protocol Container {
-    typealias ItemType
-    mutating func append(item: ItemType)
-    var count: Int { get }
-    subscript(i: Int) -> ItemType { get }
-}
-```
+
+	protocol Container {
+	    typealias ItemType
+	    mutating func append(item: ItemType)
+	    var count: Int { get }
+	    subscript(i: Int) -> ItemType { get }
+	}
+
 `Container`协议定义了三个任何容器必须支持的兼容要求：
 
 - 必须可能通过`append`方法添加一个新item到容器里；
@@ -324,29 +316,29 @@ protocol Container {
 为了达到此目的，`Container`协议声明了一个ItemType的关联类型，写作`typealias ItemType`。The protocol does not define what ItemType is an alias for—that information is left for any conforming type to provide（这个协议不会定义`ItemType`是遵循类型所提供的何种信息的别名）。尽管如此，`ItemType`别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在`append`方法和下标中的类型，以便保证任何期望的`Container`的行为是强制性的。
 
 这里是一个早前IntStack类型的非泛型版本，适用于遵循Container协议：
-```c
-struct IntStack: Container {
-    // original IntStack implementation
-    var items = Int[]()
-    mutating func push(item: Int) {
-        items.append(item)
-    }
-    mutating func pop() -> Int {
-        return items.removeLast()
-    }
-    // conformance to the Container protocol
-    typealias ItemType = Int
-    mutating func append(item: Int) {
-        self.push(item)
-    }
-    var count: Int {
-    return items.count
-    }
-    subscript(i: Int) -> Int {
-        return items[i]
-    }
-}
-```
+
+	struct IntStack: Container {
+	    // original IntStack implementation
+	    var items = Int[]()
+	    mutating func push(item: Int) {
+	        items.append(item)
+	    }
+	    mutating func pop() -> Int {
+	        return items.removeLast()
+	    }
+	    // conformance to the Container protocol
+	    typealias ItemType = Int
+	    mutating func append(item: Int) {
+	        self.push(item)
+	    }
+	    var count: Int {
+	    return items.count
+	    }
+	    subscript(i: Int) -> Int {
+	        return items[i]
+	    }
+	}
+
 
 `IntStack`类型实现了`Container`协议的所有三个要求，在`IntStack`类型的每个包含部分的功能都满足这些要求。
 
@@ -355,75 +347,76 @@ struct IntStack: Container {
 感谢Swift类型参考，你不用在`IntStack`定义部分声明一个具体的`Int`的`ItemType`。由于`IntStack`遵循`Container`协议的所有要求，只要通过简单的查找`append`方法的item参数类型和下标返回的类型，Swift就可以推断出合适的`ItemType`来使用。确实，如果上面的代码中你删除了 `typealias ItemType = Int`这一行，一切仍旧可以工作，因为它清楚的知道ItemType使用的是何种类型。
 
 你也可以生成遵循`Container`协议的泛型`Stack`类型：
-```c
-struct Stack: Container {
-    // original Stack implementation
-    var items = T[]()
-    mutating func push(item: T) {
-        items.append(item)
-    }
-    mutating func pop() -> T {
-        return items.removeLast()
-    }
-    // conformance to the Container protocol
-    mutating func append(item: T) {
-        self.push(item)
-    }
-    var count: Int {
-    return items.count
-    }
-    subscript(i: Int) -> T {
-        return items[i]
-    }
-}
-```
-这个时候，节点类型参数`T`被用作`append`方法的item参数和下标的返回类型。Swift因此可以推断出被用作这个特定容器的`ItemType`的`T`的合适类型。
+
+	struct Stack: Container {
+	    // original Stack implementation
+	    var items = T[]()
+	    mutating func push(item: T) {
+	        items.append(item)
+	    }
+	    mutating func pop() -> T {
+	        return items.removeLast()
+	    }
+	    // conformance to the Container protocol
+	    mutating func append(item: T) {
+	        self.push(item)
+	    }
+	    var count: Int {
+	    return items.count
+	    }
+	    subscript(i: Int) -> T {
+	        return items[i]
+	    }
+	}
+
+这个时候，占位类型参数`T`被用作`append`方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的`ItemType`的`T`的合适类型。
 
 
 ### 扩展一个存在的类型为一指定关联类型
 
-在[Adding Protocol Conformance with an Extension][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
+在[使用扩展来添加协议兼容性][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。
+
+Swift的`Array`已经提供`append`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳][7]中有描述这样一个实现一个空扩展的行为：
+
+	extension Array: Container {}
 
-Swift的`Array`已经提供`append`方法，一个`count`属性和通过下标来查找一个自己的元素。这三个功能都达到`Container`协议的要求。也就意味着你可以扩展`Array`去遵循`Container`协议，只要通过简单声明`Array`适用于该协议而已。如何实践这样一个空扩展，在[Declaring Protocol Adoption with an Extension][7]中有描述这样一个实现一个空扩展的行为：
-```c
-extension Array: Container {}
-```
 如同上面的泛型`Stack`类型一样，`Array的append`方法和下标保证`Swift`可以推断出`ItemType`所使用的适用的类型。定义了这个扩展后，你可以将任何`Array`当作`Container`来使用。
 
+
 ## Where 语句
 
-[Type Constraints][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
+[类型约束][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。
 
-对于关联类型的定义需求也是非常有用的。你可以通过这样去定义*where语句*作为一个类型参数队列的一部分。一个where语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个where语句，通过紧随放置`where`关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
+对于关联类型的定义需求也是非常有用的。你可以通过这样去定义*where语句*作为一个类型参数队列的一部分。一个`where`语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个`where`语句，通过紧随放置`where`关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。
 
-下面的列子定义了一个名为`allItemsMatch`的泛型函数，用来检查是否两个`Container`单例包含具有相同顺序的相同items。如果匹配到所有的items，那么返回一个为true的Boolean值，反之，则相反。
+下面的列子定义了一个名为`allItemsMatch`的泛型函数，用来检查是否两个`Container`单例包含具有相同顺序的相同元素。如果匹配到所有的元素，那么返回一个为`true`的`Boolean`值，反之，则相反。
 
-这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但他们确实拥有相同类型的items。这个需求通过一个类型约束和where语句结合来表示：
-```c
-func allItemsMatch<
-    C1: Container, C2: Container
-    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
-    (someContainer: C1, anotherContainer: C2) -> Bool {
-        
-        // check that both containers contain the same number of items
-        if someContainer.count != anotherContainer.count {
-            return false
-        }
-        
-        // check each pair of items to see if they are equivalent
-        for i in 0..someContainer.count {
-            if someContainer[i] != anotherContainer[i] {
-                return false
-            }
-        }
-        
-        // all items match, so return true
-        return true
-        
-}
-```
+这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但他们确实拥有相同类型的元素。这个需求通过一个类型约束和`where`语句结合来表示：
 
-这个函数用了两个参数：`someContainer`和`anotherContainer`。`someContainer`参数是类型`C1`，`anotherContainer`参数是类型`C2`。`C1`和`C2`是容器的两个节点类型参数，决定了这个函数何时被调用。
+	func allItemsMatch<
+	    C1: Container, C2: Container
+	    where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
+	    (someContainer: C1, anotherContainer: C2) -> Bool {
+
+	        // check that both containers contain the same number of items
+	        if someContainer.count != anotherContainer.count {
+	            return false
+	        }
+
+	        // check each pair of items to see if they are equivalent
+	        for i in 0..someContainer.count {
+	            if someContainer[i] != anotherContainer[i] {
+	                return false
+	            }
+	        }
+
+	        // all items match, so return true
+	        return true
+
+	}
+
+
+这个函数用了两个参数：`someContainer`和`anotherContainer`。`someContainer`参数是类型`C1`，`anotherContainer`参数是类型`C2`。`C1`和`C2`是容器的两个占位类型参数，决定了这个函数何时被调用。
 
 这个函数的类型参数列紧随在两个类型参数需求的后面：
 
@@ -432,54 +425,48 @@ func allItemsMatch<
 - `C1`的`ItemType`同样是C2的`ItemType`（写作 `C1.ItemType == C2.ItemType`）。
 - `C1`的`ItemType`必须遵循`Equatable`协议 (写作 `C1.ItemType: Equatable`)。
 
-第三个和第四个要求被定义为一个where语句的一部分，写在关键字`where`后面，作为函数类型参数链的一部分。
+第三个和第四个要求被定义为一个`where`语句的一部分，写在关键字`where`后面，作为函数类型参数链的一部分。
 
 这些要求意思是：
 
 `someContainer`是一个`C1`类型的容器。
 `anotherContainer`是一个`C2`类型的容器。
-`someContainer`和`anotherContainer`包含相同的items类型。
-`someContainer`中的items可以通过不等于操作(`!=`)来检查它们是否彼此不同。
+`someContainer`和`anotherContainer`包含相同的元素类型。
+`someContainer`中的元素可以通过不等于操作(`!=`)来检查它们是否彼此不同。
 
-第三个和第四个要求结合起来的意思是`anotherContainer`中的items也可以通过 `!=` 操作来检查，因为他们在`someContainer`中items确实是相同的类型。
+第三个和第四个要求结合起来的意思是`anotherContainer`中的元素也可以通过 `!=` 操作来检查，因为他们在`someContainer`中元素确实是相同的类型。
 
 这些要求能够使`allItemsMatch`函数比较两个容器，即便他们是不同的容器类型。
 
-`allItemsMatch`首先检查两个容器是否拥有同样数目的items，如果他们的items数目不同，没有办法进行匹配，函数就会`false`。
+`allItemsMatch`首先检查两个容器是否拥有同样数目的items，如果他们的元素数目不同，没有办法进行匹配，函数就会`false`。
 
-检查完之后，函数通过`for-in`循环和半闭区间操作(..)来迭代`someContainer`中的所有items。对于每个item，函数检查是否`someContainer`中的item不等于对应的`anotherContainer`中的item，如果这两个items不等，则这两个容器不匹配，返回`false`。
+检查完之后，函数通过`for-in`循环和半闭区间操作（..）来迭代`someContainer`中的所有元素。对于每个元素，函数检查是否`someContainer`中的元素不等于对应的`anotherContainer`中的元素，如果这两个元素不等，则这两个容器不匹配，返回`false`。
 
+如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回`true`。
 
-如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回true。
-
-Here’s how the allItemsMatch function looks in action:
 这里演示了allItemsMatch函数运算的过程：
-```c
-var stackOfStrings = Stack()
-stackOfStrings.push("uno")
-stackOfStrings.push("dos")
-stackOfStrings.push("tres")
- 
-var arrayOfStrings = ["uno", "dos", "tres"]
- 
-if allItemsMatch(stackOfStrings, arrayOfStrings) {
-    println("All items match.")
-} else {
-    println("Not all items match.")
-}
-// prints "All items match."
-```
- 上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但他们都遵循`Container`协议，而且他们都包含同样的类型值。你因此可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的items匹配。
 
-  [1]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown
+	var stackOfStrings = Stack()
+	stackOfStrings.push("uno")
+	stackOfStrings.push("dos")
+	stackOfStrings.push("tres")
+
+	var arrayOfStrings = ["uno", "dos", "tres"]
+
+	if allItemsMatch(stackOfStrings, arrayOfStrings) {
+	    println("All items match.")
+	} else {
+	    println("Not all items match.")
+	}
+	// 输出 "All items match."
+
+ 上面的例子创建一个`Stack`单例来存储`String`，然后压了三个字符串进栈。这个例子也创建了一个`Array`单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但他们都遵循`Container`协议，而且他们都包含同样的类型值。你因此可以调用`allItemsMatch`函数，用这两个容器作为它的参数。在上面的例子中，`allItemsMatch`函数正确的显示了所有的这两个容器的`items`匹配。
+
+  [1]: ../chapter2/06_Functions.html
   [2]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushPop_2x.png
   [3]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPushedFourStrings_2x.png
   [4]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/stackPoppedOneString_2x.png
-  [5]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/CollectionTypes.html#//apple_ref/doc/uid/TP40014097-CH8-XID_143
-  [6]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_355
-  [7]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_357
-  [8]: https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Generics.html#//apple_ref/doc/uid/TP40014097-CH26-XID_244
-  [9]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown
-  [10]: https://www.zybuluo.com/mdeditor?url=https://www.zybuluo.com/static/editor/md-help.markdown#cmd-markdown-高阶语法手册
-  [11]: http://weibo.com/ghosert
-  [12]: http://meta.math.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference
+  [5]: ../chapter2/04_Collection_Types.html
+  [6]: ../chapter2/21_Protocols.html
+  [7]: ../chapter2/21_Protocols.html
+  [8]: #type_constraints
diff --git a/source/chapter2/23_Advanced_Operators.md b/source/chapter2/23_Advanced_Operators.md
index 4fa43477..e2f557b3 100644
--- a/source/chapter2/23_Advanced_Operators.md
+++ b/source/chapter2/23_Advanced_Operators.md
@@ -1,3 +1,7 @@
+> 翻译：xielingwang
+
+> 校对：numbbbbb
+
 # 高级运算符
 -----------------
 
@@ -9,47 +13,27 @@
 - [运算符函数(Operator Functions)](#operator_functions)
 - [自定义运算符](#custom_operators)
 
-In addition to the operators described in [Basic Operators](Basic Operators), Swift provides several advanced operators that perform more complex value manipulation. These include all of the bitwise and bit shifting operators you will be familiar with from C and Objective-C.
-
 除了[基本操作符](02_Basic_Operators.html)中所讲的运算符，Swift还有许多复杂的高级运算符，包括了C语和Objective-C中的位运算符和移位运算。
 
-Unlike arithmetic operators in C, arithmetic operators in Swift do not overflow by default. Overflow behavior is trapped and reported as an error. To opt in to overflow behavior, use Swift’s second set of arithmetic operators that overflow by default, such as the overflow addition operator (&+). All of these overflow operators begin with an ampersand (&).
-
 不同于C语言中的数值计算，Swift的数值计算默认是不可溢出的。溢出行为会被捕获并报告为错误。你是故意的？好吧，你可以使用Swift为你准备的另一套默认允许溢出的数值运算符，如可溢出加`&+`。所有允许溢出的运算符都是以`&`开始的。
 
-When you define your own structures, classes, and enumerations, it can be useful to provide your own implementations of the standard Swift operators for these custom types. Swift makes it easy to provide tailored implementations of these operators and to determine exactly what their behavior should be for each type you create.
-
 自定义的结构，类和枚举，是否可以使用标准的运算符来定义操作？当然可以！在Swift中，你可以为你创建的所有类型定制运算符的操作。
 
-You’re not just limited to the predefined operators. Swift gives you the freedom to define your own custom infix, prefix, postfix, and assignment operators, with custom precedence and associativity values. These operators can be used and adopted in your code just like any of the predefined operators, and you can even extend existing types to support the custom operators you define.
-
 可定制的运算符并不限于那些预设的运算符，自定义有个性的中置，前置，后置及赋值运算符，当然还有优先级和结合性。这些运算符的实现可以运用预设的运算符，也可以运用之前定制的运算符。
 
-## Bitwise Operators
-
 
 ## 位运算符
 
-Bitwise operators enable you to manipulate the individual raw data bits within a data structure. They are often used in low-level programming, such as graphics programming and device driver creation. Bitwise operators can also be useful when you work with raw data from external sources, such as encoding and decoding data for communication over a custom protocol.
-
 位操作符通常在诸如图像处理和创建设备驱动等底层开发中使用，使用它可以单独操作数据结构中原始数据的比特位。在使用一个自定义的协议进行通信的时候，运用位运算符来对原始数据进行编码和解码也是非常有效的。
 
-Swift supports all of the bitwise operators found in C, as described below.
-
 Swift支持如下所有C语言的位运算符：
 
-### Bitwise NOT Operator
-
 ### 按位取反运算符
- 
-The bitwise NOT operator (~) inverts all bits in a number:
 
 按位取反运算符`~`对一个操作数的每一位都取反。
 
 ![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")
 
-The bitwise NOT operator is a prefix operator, and appears immediately before the value it operates on, without any white space:
-
 这个运算符是前置的，所以请不加任何空格地写着操作数之前。
 
 ```
@@ -57,26 +41,16 @@ let initialBits: UInt8 = 0b00001111
 let invertedBits = ~initialBits  // 等于 0b11110000
 ```
 
-UInt8 integers have eight bits and can store any value between 0 and 255. This example initializes a UInt8 integer with the binary value 00001111, which has its first four bits set to 0, and its second four bits set to 1. This is equivalent to a decimal value of 15.
-
 `UInt8`是8位无符整型，可以存储0~255之间的任意数。这个例子初始化一个整型为二进制值`00001111`(前4位为`0`，后4位为`1`)，它的十进制值为`15`。
 
-The bitwise NOT operator is then used to create a new constant called invertedBits, which is equal to initialBits, but with all of the bits inverted. Zeroes become ones, and ones become zeroes. The value of invertedBits is 11110000, which is equal to an unsigned decimal value of 240.
-
 使用按位取反运算`~`对`initialBits`操作，然后赋值给`invertedBits`这个新常量。这个新常量的值等于所有位都取反的`initialBits`，即`1`变成`0`，`0`变成`1`，变成了`11110000`，十进制值为`240`。
 
-### Bitwise AND Operator
-
 ### 按位与运算符
 
-The bitwise AND operator (&) combines the bits of two numbers. It returns a new number whose bits are set to 1 only if the bits were equal to 1 in both input numbers:
-
 按位与运算符对两个数进行操作，然后返回一个新的数，这个数的每个位都需要两个输入数的同一位都为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")
 
-In the example below, the values of firstSixBits and lastSixBits both have four middle bits equal to 1. The bitwise AND operator combines them to make the number 00111100, which is equal to an unsigned decimal value of 60:
-
 以下代码，`firstSixBits`和`lastSixBits`中间4个位都为1。对它俩进行按位与运算后，就得到了`00111100`，即十进制的`60`。
 
 ```
@@ -85,18 +59,12 @@ let lastSixBits: UInt8  = 0b00111111
 let middleFourBits = firstSixBits & lastSixBits  // 等于 00111100
 ```
 
-### Bitwise OR Operator
-
 ### 按位或运算
 
-The bitwise OR operator (|) compares the bits of two numbers. The operator returns a new number whose bits are set to 1 if the bits are equal to 1 in either input number:
-
 按位或运算符`|`比较两个数，然后返回一个新的数，这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为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")
 
-In the example below, the values of someBits and moreBits have different bits set to 1. The bitwise OR operator combines them to make the number 11111110, which equals an unsigned decimal of 254:
-
 如下代码，`someBits`和`moreBits`在不同位上有`1`。按位或运行的结果是`11111110`，即十进制的`254`。
 
 ```
@@ -105,18 +73,12 @@ let moreBits: UInt8 = 0b01011110
 let combinedbits = someBits | moreBits  // 等于 11111110
 ```
 
-### Bitwise XOR Operator
-
 ### 按位异或运算符
 
-The bitwise XOR operator, or “exclusive OR operator” (^), compares the bits of two numbers. The operator returns a new number whose bits are set to 1 where the input bits are different and are set to 0 where the input bits are the same:
-
 按位异或运算符`^`比较两个数，然后返回一个数，这个数的每个位设为`1`的条件是两个输入数的同一位不同，如果相同就设为`0`。
 
 ![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")
 
-In the example below, the values of firstBits and otherBits each have a bit set to 1 in a location that the other does not. The bitwise XOR operator sets both of these bits to 1 in its output value. All of the other bits in firstBits and otherBits match and are set to 0 in the output value:
-
 以下代码，`firstBits`和`otherBits`都有一个`1`跟另一个数不同的。所以按位异或的结果是把它这些位置为`1`，其他都置为`0`。
 
 ```
@@ -125,36 +87,21 @@ let otherBits: UInt8 = 0b00000101
 let outputBits = firstBits ^ otherBits  // 等于 00010001
 ```
 
-### Bitwise Left and Right Shift Operators
 ### 按位左移/右移运算符
 
-The bitwise left shift operator (<<) and bitwise right shift operator (>>) move all bits in a number to the left or the right by a certain number of places, according to the rules defined below.
-
 左移运算符`<<`和右移运算符`>>`会把一个数的所有比特位按以下定义的规则向左或向右移动指定位数。
 
-Bitwise left and right shifts have the effect of multiplying or dividing an integer number by a factor of two. Shifting an integer’s bits to the left by one position doubles its value, whereas shifting it to the right by one position halves its value.
-
 按位左移和按位右移的效果相当把一个整数乘于或除于一个因子为`2`的整数。向左移动一个整型的比特位相当于把这个数乘于`2`，向右移一位就是除于`2`。
 
-#### Shifting Behavior for Unsigned Integers
 #### 无符整型的移位操作
 
-The bit-shifting behavior for unsigned integers is as follows:
 对无符整型的移位的效果如下：
 
-Existing bits are moved to the left or right by the requested number of places.
-Any bits that are moved beyond the bounds of the integer’s storage are discarded.
-Zeroes are inserted in the spaces left behind after the original bits are moved to the left or right.
-This approach is known as a logical shift.
-
 已经存在的比特位向左或向右移动指定的位数。被移出整型存储边界的的位数直接抛弃，移动留下的空白位用零`0`来填充。这种方法称为逻辑移位。
 
-The illustration below shows the results of 11111111 << 1 (which is 11111111 shifted to the left by 1 place), and 11111111 >> 1 (which is 11111111 shifted to the right by 1 place). Blue numbers are shifted, gray numbers are discarded, and orange zeroes are inserted:
-
 以下这张把展示了 `11111111 << 1`(`11111111`向左移1位)，和 `11111111 >> 1`(`11111111`向右移1位)。蓝色的是被移位的，灰色是被抛弃的，橙色的`0`是被填充进来的。
 
 ![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")
-Here’s how bit shifting looks in Swift code:
 
 ```
 let shiftBits: UInt8 = 4   // 即二进制的00000100
@@ -165,7 +112,6 @@ shiftBits << 6             // 00000000
 shiftBits >> 2             // 00000001
 ```
 
-You can use bit shifting to encode and decode values within other data types:
 你可以使用移位操作进行其他数据类型的编码和解码。
 
 ```
@@ -175,103 +121,59 @@ let greenComponent = (pink & 0x00FF00) >> 8   // greenComponent 是 0x66, 即 10
 let blueComponent = pink & 0x0000FF           // blueComponent 是 0x99, 即 153
 ```
 
-This example uses a UInt32 constant called pink to store a Cascading Style Sheets color value for the color pink. The CSS color value #CC6699 is written as 0xCC6699 in Swift’s hexadecimal number representation. This color is then decomposed into its red (CC), green (66), and blue (99) components by the bitwise AND operator (&) and the bitwise right shift operator (>>).
-
 这个例子使用了一个`UInt32`的命名为`pink`的常量来存储层叠样式表`CSS`中粉色的颜色值，`CSS`颜色`#CC6699`在Swift用十六进制`0xCC6699`来表示。然后使用按位与(&)和按位右移就可以从这个颜色值中解析出红(CC)，绿(66)，蓝(99)三个部分。
 
-The red component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0xFF0000. The zeroes in 0xFF0000 effectively “mask” the second and third bytes of 0xCC6699, causing the 6699 to be ignored and leaving 0xCC0000 as the result.
-
 对`0xCC6699`和`0xFF0000`进行按位与`&`操作就可以得到红色部分。`0xFF0000`中的`0`了遮盖了`OxCC6699`的第二和第三个字节，这样`6699`被忽略了，只留下`0xCC0000`。
 
-This number is then shifted 16 places to the right (>> 16). Each pair of characters in a hexadecimal number uses 8 bits, so a move 16 places to the right will convert 0xCC0000 into 0x0000CC. This is the same as 0xCC, which has a decimal value of 204.
-
 然后，按向右移动16位，即 `>> 16`。十六进制中每两个字符是8比特位，所以移动16位的结果是把`0xCC0000`变成`0x0000CC`。这和`0xCC`是相等的，都是十进制的`204`。
 
-Similarly, the green component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x00FF00, which gives an output value of 0x006600. This output value is then shifted eight places to the right, giving a a value of 0x66, which has a decimal value of 102.
-
 同样的，绿色部分来自于`0xCC6699`和`0x00FF00`的按位操作得到`0x006600`。然后向右移动8們，得到`0x66`，即十进制的`102`。
 
-Finally, the blue component is obtained by performing a bitwise AND between the numbers 0xCC6699 and 0x0000FF, which gives an output value of 0x000099. There’s no need to shift this to the right, as 0x000099 already equals 0x99, which has a decimal value of 153.
-
 最后，蓝色部分对`0xCC6699`和`0x0000FF`进行按位与运算，得到`0x000099`，无需向右移位了，所以结果就是`0x99`，即十进制的`153`。
 
-#### Shifting Behavior for Signed Integers
 #### 有符整型的移位操作
 
-The shifting behavior is more complex for signed integers than for unsigned integers, because of the way signed integers are represented in binary. (The examples below are based on 8-bit signed integers for simplicity, but the same principles apply for signed integers of any size.)
-
 有符整型的移位操作相对复杂得多，因为正负号也是用二进制位表示的。(这里举的例子虽然都是8位的，但它的原理是通用的。)
 
-Signed integers use their first bit (known as the sign bit) to indicate whether the integer is positive or negative. A sign bit of 0 means positive, and a sign bit of 1 means negative.
-
 有符整型通过第1个比特位(称为符号位)来表达这个整数是正数还是负数。`0`代表正数，`1`代表负数。
 
-The remaining bits (known as the value bits) store the actual value. Positive numbers are stored in exactly the same way as for unsigned integers, counting upwards from 0. Here’s how the bits inside an Int8 look for the number 4:
-
 其余的比特位(称为数值位)存储其实值。有符正整数和无符正整数在计算机里的存储结果是一样的，下来我们来看`+4`内部的二进制结构。
 
 ![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")
 
-The sign bit is 0 (meaning “positive”), and the seven value bits are just the number 4, written in binary notation.
-
 符号位为`0`，代表正数，另外7比特位二进制表示的实际值就刚好是`4`。
 
-Negative numbers, however, are stored differently. They are stored by subtracting their absolute value from 2 to the power of n, where n is the number of value bits. An eight-bit number has seven value bits, so this means 2 to the power of 7, or 128.
-
 负数呢，跟正数不同。负数存储的是2的n次方减去它的绝对值，n为数值位的位数。一个8比特的数有7个数值位，所以是2的7次方，即128。
 
-Here’s how the bits inside an Int8 look for the number -4:
-
 我们来看`-4`存储的二进制结构。
 
 ![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")
 
-This time, the sign bit is 1 (meaning “negative”), and the seven value bits have a binary value of 124 (which is 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")
 
-The encoding for negative numbers is known as a two’s complement representation. It may seem an unusual way to represent negative numbers, but it has several advantages.
-
 负数的编码方式称为二进制补码表示。这种表示方式看起来很奇怪，但它有几个优点。
 
-First, you can add -1 to -4, simply by performing a standard binary addition of all eight bits (including the sign bit), and discarding anything that doesn’t fit in the eight bits once you’re done:
-
 首先，只需要对全部8个比特位(包括符号)做标准的二进制加法就可以完成 `-1 + -4` 的操作，忽略加法过程产生的超过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")
 
-Second, the two’s complement representation also lets you shift the bits of negative numbers to the left and right like positive numbers, and still end up doubling them for every shift you make to the left, or halving them for every shift you make to the right. To achieve this, an extra rule is used when signed integers are shifted to the right:
-
 第二，由于使用二进制补码表示，我们可以和正数一样对负数进行按位左移右移的，同样也是左移1位时乘于`2`，右移1位时除于`2`。要达到此目的，对有符整型的右移有一个特别的要求：
 
-When you shift signed integers to the right, apply the same rules as for unsigned integers, but fill any empty bits on the left with the sign bit, rather than with a zero.
-
 对有符整型按位右移时，使用符号位(正数为`0`，负数为`1`)填充空白位。
 
 ![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")
 
-
-This action ensures that signed integers have the same sign after they are shifted to the right, and is known as an arithmetic shift.
-
 这就确保了在右移的过程中，有符整型的符号不会发生变化。这称为算术移位。
 
-Because of the special way that positive and negative numbers are stored, shifting either of them to the right moves them closer to zero. Keeping the sign bit the same during this shift means that negative integers remain negative as their value moves closer to zero.
-
 正因为正数和负数特殊的存储方式，向右移位使它接近于`0`。移位过程中保持符号会不变，负数在接近`0`的过程中一直是负数。
 
-## Overflow Operators
-
 
 ## 溢出运算符
 
-If you try to insert a number into an integer constant or variable that cannot hold that value, by default Swift reports an error rather than allowing an invalid value to be created. This behavior gives extra safety when you work with numbers that are too large or too small.
-
 默认情况下，当你往一个整型常量或变量赋于一个它不能承载的大数时，Swift不会让你这么干的，它会报错。这样，在操作过大或过小的数的时候就很安全了。
 
-For example, the Int16 integer type can hold any signed integer number between -32768 and 32767. Trying to set a UInt16 constant or variable to a number outside of this range causes an error:
-
 例如，`Int16`整型能承载的整数范围是`-32768`到`32767`，如果给它赋上超过这个范围的数，就会报错：
 
 ```
@@ -281,12 +183,8 @@ potentialOverflow += 1
 // 噢, 出错了
 ```
 
-Providing error handling when values get too large or too small gives you much more flexibility when coding for boundary value conditions.
-
 对过大或过小的数值进行错误处理让你的数值边界条件更灵活。
 
-However, when you specifically want an overflow condition to truncate the number of available bits, you can opt in to this behavior rather than triggering an error. Swift provides five arithmetic overflow operators that opt in to the overflow behavior for integer calculations. These operators all begin with an ampersand (&):
-
 当然，你有意在溢出时对有效位进行截断，你可采用溢出运算，而非错误处理。Swfit为整型计算提供了5个`&`符号开头的溢出运算符。
 
 - 溢出加法 `&+`
@@ -295,11 +193,8 @@ However, when you specifically want an overflow condition to truncate the number
 - 溢出除法 `&/`
 - 溢出求余 `&%`
 
-### Value Overflow
 ### 值的上溢出
 
-Here’s an example of what happens when an unsigned value is allowed to overflow, using the overflow addition operator (&+):
-
 下面例子使用了溢出加法`&+`来解剖的无符整数的上溢出
 
 ```
@@ -309,26 +204,18 @@ willOverflow = willOverflow &+ 1
 // 这时候 willOverflow 等于 0
 ```
 
-The variable willOverflow is initialized with the largest value a UInt8 can hold (255, or 11111111 in binary). It is then incremented by 1 using the overflow addition operator (&+). This pushes its binary representation just over the size that a UInt8 can hold, causing it to overflow beyond its bounds, as shown in the diagram below. The value that remains within the bounds of the UInt8 after the overflow addition is 00000000, or zero:
-
 `willOverflow`用`Int8`所能承载的最大值`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")
 
-### Value Underflow
 ### 值的下溢出
 
-Numbers can also become too small to fit in their type’s maximum bounds. Here’s an example.
 数值也有可能因为太小而越界。举个例子：
 
-The smallest value that a UInt8 can hold is 0 (which is 00000000 in eight-bit binary form). If you subtract 1 from 00000000 using the overflow subtraction operator, the number will overflow back round to 11111111, or 255 in decimal:
-
 `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")
 
-
-Here’s how that looks in Swift code:
 Swift代码是这样的:
 
 ```
@@ -338,14 +225,10 @@ willUnderflow = willUnderflow &- 1
 // 此时 willUnderflow 等于 255
 ```
 
-A similar underflow occurs for signed integers. All subtraction for signed integers is performed as straight binary subtraction, with the sign bit included as part of the numbers being subtracted, as described in Bitwise Left and Right Shift Operators. The smallest number that an Int8 can hold is -128, which is 10000000 in binary. Subtracting 1 from this binary number with the overflow operator gives a binary value of 01111111, which toggles the sign bit and gives positive 127, the largest positive value that an Int8 can hold:
-
 有符整型也有类似的下溢出，有符整型所有的减法也都是对包括在符号位在内的二进制数进行二进制减法的，这在 "按位左移/右移运算符" 一节提到过。最小的有符整数是`-128`，即二进制的`10000000`。用溢出减法减去去1后，变成了`01111111`，即UInt8所能承载的最大整数`127`。
 
 ![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")
 
-Here’s the same thing in Swift code:
-
 来看看Swift代码：
 
 ```
@@ -355,13 +238,8 @@ signedUnderflow = signedUnderflow &- 1
 // 如今 signedUnderflow 等于 127
 ```
 
-The end result of the overflow and underflow behavior described above is that for both signed and unsigned integers, overflow always wraps around from the largest valid integer value back to the smallest, and underflow always wraps around from the smallest value to the largest.
-
-### Division by Zero
 ### 除零溢出
 
-Dividing a number by zero(i / 0), or trying to calculate remainder by zero(i % 0), causes an error:
-
 一个数除于0 `i / 0`，或者对0求余数 `i % 0`，就会产生一个错误。
 
 ```
@@ -369,8 +247,6 @@ let x = 1
 let y = x / 0
 ```
 
-However, the overflow versions of these operators (&/ and &%) return a value of zero if you divide by zero:
-
 使用它们对应的可溢出的版本的运算符`&/`和`&%`进行除0操作时就会得到`0`值。
 
 ```
@@ -379,21 +255,13 @@ let y = x &/ 0
 // y 等于 0
 ```
 
-## Precedence and Associativity
-
 
 ## 优先级和结合性
 
-Operator precedence gives some operators higher priority than others; these operators are calculated first.
-
 运算符的优先级使得一些运算符优先于其他运算符，高优先级的运算符会先被计算。
 
-Operator associativity defines how operators of the same precedence are grouped together (or associated)—either grouped from the left, or grouped from the right. Think of it as meaning “they associate with the expression to their left,” or “they associate with the expression to their right.”
-
 结合性定义相同优先级的运算符在一起时是怎么组合或关联的，是和左边的一组呢，还是和右边的一组。意思就是，到底是和左边的表达式结合呢，还是和右边的表达式结合？
 
-It is important to consider each operator’s precedence and associativity when working out the order in which a compound expression will be calculated. Here’s an example. Why does the following expression equal 4?
-
 在混合表达式中，运算符的优先级和结合性是非常重要的。举个例子，为什么下列表达式的结果为`4`？
 
 ```
@@ -401,8 +269,6 @@ It is important to consider each operator’s precedence and associativity when
 // 结果是 4
 ```
 
-Taken strictly from left to right, you might expect this to read as follows:
-
 如果严格地从左计算到右，计算过程会是这样：
 
 - 2 plus 3 equals 5;
@@ -412,12 +278,8 @@ Taken strictly from left to right, you might expect this to read as follows:
 - 20 remainder 5 equals 0
 - 20 / 5 = 4 余 0
 
-However, the actual answer is 4, not 0. Higher-precedence operators are evaluated before lower-precedence ones. In Swift, as in C, the multiplication operator (*) and the remainder operator (%) have a higher precedence than the addition operator (+). As a result, they are both evaluated before the addition is considered.
-
 但是正确答案是`4`而不是`0`。优先级高的运算符要先计算，在Swift和C语言中，都是先乘除后加减的。所以，执行完乘法和求余运算才能执行加减运算。
 
-However, multiplication and remainder have the same precedence as each other. To work out the exact evaluation order to use, you also need to consider their associativity. Multiplication and remainder both associate with the expression to their left. Think of this as adding implicit parentheses around these parts of the expression, starting from their left:
-
 乘法和求余拥有相同的优先级，在运算过程中，我们还需要结合性，乘法和求余运算都是左结合的。这相当于在表达式中有隐藏的括号让运算从左开始。
 
 ```
@@ -439,34 +301,19 @@ However, multiplication and remainder have the same precedence as each other. To
 2 + 2
 ```
 
-This calculation yields the final answer of 4.
-
 计算结果为 4。
 
-For a complete list of Swift operator precedences and associativity rules, see [Expressions](Expressions).
-
 查阅Swift运算符的优先级和结合性的完整列表，请看[表达式](../chapter3/04_Expressions.html)。
 
-> NOTE
-
-> Swift’s operator precedences and associativity rules are simpler and more predictable than those found in C and Objective-C. However, this means that they are not the same as in C-based languages. Be careful to ensure that operator interactions still behave in the way you intend when porting existing code to Swift.
-
 > 注意：
+>
 Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。
 
-## Operator Functions
-
 
 ## 运算符函数
 
-Classes and structures can provide their own implementations of existing operators. This is known as overloading the existing operators.
-
 让已有的运算符也可以对自定义的类和结构进行运算，这称为运算符重载。
 
-The example below shows how to implement the arithmetic addition operator (+) for a custom structure. The arithmetic addition operator is a binary operator because it operates on two targets and is said to be infix because it appears in between those two targets.
-
-The example defines a Vector2D structure for a two-dimensional position vector (x, y), followed by a definition of an operator function to add together instances of the Vector2D structure:
-
 这个例子展示了如何用`+`让一个自定义的结构做加法。算术运算符`+`是一个两目运算符，因为它有两个操作数，而且它必须出现在两个操作数之间。
 
 例子中定义了一个名为`Vector2D`的二维坐标向量 `(x，y)` 的结构，然后定义了让两个`Vector2D`的对象相加的运算符函数。
@@ -480,16 +327,11 @@ struct Vector2D {
 }
 ```
 
-The operator function is defined as a global function called +, which takes two input parameters of type Vector2D and returns a single output value, also of type Vector2D. You implement an infix operator by writing the @infix attribute before the func keyword when declaring the operator function.
-
 该运算符函数定义了一个全局的`+`函数，这个函数需要两个`Vector2D`类型的参数，返回值也是`Vector2D`类型。需要定义和实现一个中置运算的时候，在关键字`func`之前写上属性 `@infix` 就可以了。
 
-In this implementation, the input parameters are named left and right to represent the Vector2D instances that will be on the left side and right side of the + operator. The function returns a new Vector2D instance, whose x and y properties are initialized with the sum of the x and y properties from the two Vector2D instances that are added together.
 
 在这个代码实现中，参数被命名为了`left`和`right`，代表`+`左边和右边的两个`Vector2D`对象。函数返回了一个新的`Vector2D`的对象，这个对象的`x`和`y`分别等于两个参数对象的`x`和`y`的和。
 
-The function is defined globally, rather than as a method on the Vector2D structure, so that it can be used as an infix operator between existing Vector2D instances:
-
 这个函数是全局的，而不是`Vector2D`结构的成员方法，所以任意两个`Vector2D`对象都可以使用这个中置运算符。
 
 ```
@@ -499,19 +341,12 @@ let combinedVector = vector + anotherVector
 // combinedVector 是一个新的Vector2D, 值为 (5.0, 5.0)
 ```
 
-This example adds together the vectors (3.0, 1.0) and (2.0, 4.0) to make the vector (5.0, 5.0), as illustrated below.
-
 这个例子实现两个向量 `(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")
 
-### Prefix and Postfix Operators
 ### 前置和后置运算符
 
-The example shown above demonstrates a custom implementation of a binary infix operator. Classes and structures can also provide implementations of the standard unary operators. Unary operators operate on a single target. They are prefix if they precede their target (such as -a) and postfix operators if they follow their target (such as i++).
-
-You implement a prefix or postfix unary operator by writing the @prefix or @postfix attribute before the func keyword when declaring the operator function:
-
 上个例子演示了一个双目中置运算符的自定义实现，同样我们也可以玩标准单目运算符的实现。单目运算符只有一个操作数，在操作数之前就是前置的，如`-a`; 在操作数之后就是后置的，如`i++`。
 
 实现一个前置或后置运算符时，在定义该运算符的时候于关键字`func`之前标注 `@prefix` 或 `@postfix` 属性。
@@ -522,12 +357,8 @@ You implement a prefix or postfix unary operator by writing the @prefix or @post
 }
 ```
 
-The example above implements the unary minus operator (-a) for Vector2D instances. The unary minus operator is a prefix operator, and so this function has to be qualified with the @prefix attribute.
-
 这段代码为`Vector2D`类型提供了单目减运算`-a`，`@prefix`属性表明这是个前置运算符。
 
-For simple numeric values, the unary minus operator converts positive numbers into their negative equivalent and vice versa. The corresponding implementation for Vector2D instances performs this operation on both the x and y properties:
-
 对于数值，单目减运算符可以把正数变负数，把负数变正数。对于`Vector2D`，单目减运算将其`x`和`y`都进进行单目减运算。
 
 ```
@@ -538,13 +369,8 @@ let alsoPositive = -negative
 // alsoPositive 为 (3.0, 4.0)
 ```
 
-### Compound Assignment Operators
 ### 组合赋值运算符
 
-Compound assignment operators combine assignment (=) with another operation. For example, the addition assignment operator (+=) combines addition and assignment into a single operation. Operator functions that implement compound assignment must be qualified with the @assignment attribute. You must also mark a compound assignment operator’s left input parameter as inout, because the parameter’s value will be modified directly from within the operator function.
-
-The example below implements an addition assignment operator function for Vector2D instances:
-
 组合赋值是其他运算符和赋值运算符一起执行的运算。如`+=`把加运算和赋值运算组合成一个操作。实现一个组合赋值符号需要使用`@assignment`属性，还需要把运算符的左参数设置成`inout`，因为这个参数会在运算符函数内直接修改它的值。
 
 ```
@@ -553,8 +379,6 @@ The example below implements an addition assignment operator function for Vector
 }
 ```
 
-Because an addition operator was defined earlier, you don’t need to reimplement the addition process here. Instead, the addition assignment operator function takes advantage of the existing addition operator function, and uses it to set the left value to be the left value plus the right value:
-
 因为加法运算在之前定义过了，这里无需重新定义。所以，加赋运算符函数使用已经存在的高级加法运算符函数来执行左值加右值的运算。
 
 ```
@@ -564,8 +388,6 @@ original += vectorToAdd
 // original 现在为 (4.0, 6.0)
 ```
 
-You can combine the @assignment attribute with either the @prefix or @postfix attribute, as in this implementation of the prefix increment operator (++a) for Vector2D instances:
-
 你可以将 `@assignment` 属性和 `@prefix` 或 `@postfix` 属性起来组合，实现一个`Vector2D`的前置运算符。
 
 ```
@@ -575,8 +397,6 @@ You can combine the @assignment attribute with either the @prefix or @postfix at
 }
 ```
 
-The prefix increment operator function above takes advantage of the addition assignment operator defined earlier. It adds a Vector2D with x and y values of 1.0 to the Vector2D on which it is called, and returns the result:
-
 这个前置使用了已经定义好的高级加赋运算，将自己加上一个值为 `(1.0，1.0)` 的对象然后赋给自己，然后再将自己返回。
 
 ```
@@ -586,22 +406,14 @@ let afterIncrement = ++toIncrement
 // afterIncrement 现在也是 (4.0, 5.0)
 ```
 
-> NOTE
-
-> It is not possible to overload the default assignment operator (=). Only the compound assignment operators can be overloaded. Similarly, the ternary conditional operator (a ? b : c) cannot be overloaded.
-
 >注意：
+>
 默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 `a？b：c` 也是不可重载。
 
-### Equivalence Operators
 ### 比较运算符
 
-Custom classes and structures do not receive a default implementation of the equivalence operators, known as the “equal to” operator (==) and “not equal to” operator (!=). It is not possible for Swift to guess what would qualify as “equal” for your own custom types, because the meaning of “equal” depends on the roles that those types play in your code.
-
 Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符`==`或`!=`就需要重载。
 
-To use the equivalence operators to check for equivalence of your own custom type, provide an implementation of the operators in the same way as for other infix operators:
-
 定义相等运算符函数跟定义其他中置运算符雷同：
 
 ```
@@ -614,12 +426,8 @@ To use the equivalence operators to check for equivalence of your own custom typ
 }
 ```
 
-The above example implements an “equal to” operator (==) to check if two Vector2D instances have equivalent values. In the context of Vector2D, it makes sense to consider “equal” as meaning “both instances have the same x values and y values”, and so this is the logic used by the operator implementation. The example also implements the “not equal to” operator (!=), which simply returns the inverse of the result of the “equal to” operator.
-
 上述代码实现了相等运算符`==`来判断两个`Vector2D`对象是否有相等的值，相等的概念就是他们有相同的`x`值和相同的`y`值，我们就用这个逻辑来实现。接着使用`==`的结果实现了不相等运算符`!=`。
 
-You can now use these operators to check whether two Vector2D instances are equivalent:
-
 现在我们可以使用这两个运算符来判断两个`Vector2D`对象是否相等。
 
 ```
@@ -631,22 +439,16 @@ if twoThree == anotherTwoThree {
 // prints "这两个向量是相等的."
 ```
 
-### Custom Operators
 ### 自定义运算符
 
-You can declare and implement your own custom operators in addition to the standard operators provided by Swift. Custom operators can be defined only with the characters / = - + * % < > ! & | ^ . ~.
-
 标准的运算符不够玩，那你可以声明一些个性的运算符，但个性的运算符只能使用这些字符 `/ = - + * % < >！& | ^。~`。
 
-New operators are declared at a global level using the operator keyword, and can be declared as prefix, infix or postfix:
-
 新的运算符声明需在全局域使用`operator`关键字声明，可以声明为前置，中置或后置的。
 
 ```
 operator prefix +++ {}
 ```
 
-The example above defines a new prefix operator called +++. This operator does not have an existing meaning in Swift, and so it is given its own custom meaning below in the specific context of working with Vector2D instances. For the purposes of this example, +++ is treated as a new “prefix doubling incrementer” operator. It doubles the x and y values of a Vector2D instance, by adding the vector to itself with the addition assignment operator defined earlier:
 
 这段代码定义了一个新的前置运算符叫`+++`，此前Swift并不存在这个运算符。此处为了演示，我们让`+++`对`Vector2D`对象的操作定义为 `双自增` 这样一个独有的操作，这个操作使用了之前定义的加赋运算实现了自已加上自己然后返回的运算。
 
@@ -657,9 +459,7 @@ The example above defines a new prefix operator called +++. This operator does n
 }
 ```
 
-This implementation of +++ is very similar to the implementation of ++ for Vector2D, except that this operator function adds the vector to itself, rather than adding Vector2D(1.0, 1.0):
-
-`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量. 
+`Vector2D` 的 `+++` 的实现和 `++` 的实现很接近, 唯一不同的前者是加自己, 后者是加值为 `(1.0, 1.0)` 的向量.
 
 ```
 var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
@@ -668,23 +468,14 @@ let afterDoubling = +++toBeDoubled
 // afterDoubling 现在也是 (2.0, 8.0)
 ```
 
-### Precedence and Associativity for Custom Infix Operators
 ### 自定义中置运算符的优先级和结合性
 
-Custom infix operators can also specify a precedence and an associativity. See [Precedence and Associativity](#PrecedenceandAssociativity) for an explanation of how these two characteristics affect an infix operator’s interaction with other infix operators.
-
 可以为自定义的中置运算符指定优先级和结合性。可以回头看看[优先级和结合性](#PrecedenceandAssociativity)解释这两个因素是如何影响多种中置运算符混合的表达式的计算的。
 
-The possible values for associativity are left, right, and none. Left-associative operators associate to the left if written next to other left-associative operators of the same precedence. Similarly, right-associative operators associate to the right if written next to other right-associative operators of the same precedence. Non-associative operators cannot be written next to other operators with the same precedence.
-
 结合性(associativity)的值可取的值有`left`，`right`和`none`。左结合运算符跟其他优先级相同的左结合运算符写在一起时，会跟左边的操作数结合。同理，右结合运算符会跟右边的操作数结合。而非结合运算符不能跟其他相同优先级的运算符写在一起。
 
-The associativity value defaults to none if it is not specified. The precedence value defaults to 100 if it is not specified.
-
 结合性(associativity)的值默认为`none`，优先级(precedence)默认为`100`。
 
-The following example defines a new custom infix operator called +-, with left associativity and a precedence of 140:
-
 以下例子定义了一个新的中置符`+-`，是左结合的`left`，优先级为`140`。
 
 ```
@@ -698,6 +489,4 @@ let plusMinusVector = firstVector +- secondVector
 // plusMinusVector 此时的值为 (4.0, -2.0)
 ```
 
-This operator adds together the x values of two vectors, and subtracts the y value of the second vector from the first. Because it is in essence an “additive” operator, it has been given the same associativity and precedence values (left and 140) as default additive infix operators such as + and -. For a complete list of the default Swift operator precedence and associativity settings, see [Expressions](Expressions).
-
-这个运算符把两个向量的`x`相加，把向量的`y`相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(`left`和`140`)。查阅完整的Swift默认结合性和优先级的设置，请移步[表达式](../chapter3/04_Expressions.html);
\ No newline at end of file
+这个运算符把两个向量的`x`相加，把向量的`y`相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(`left`和`140`)。查阅完整的Swift默认结合性和优先级的设置，请移步[表达式](../chapter3/04_Expressions.html);
diff --git a/source/chapter3/01_About_the_Language_Reference.md b/source/chapter3/01_About_the_Language_Reference.md
index a537578c..d3a0cfb0 100644
--- a/source/chapter3/01_About_the_Language_Reference.md
+++ b/source/chapter3/01_About_the_Language_Reference.md
@@ -1,12 +1,22 @@
+> 翻译：ChildhoodAndy
+
+> 校对：numbbbbb
+
+
 # 关于语言附注
 -----------------
 
+本页内容包括：
+
+- [如何阅读语法](#how_to_read_the_grammar)
+
 本书的这一节描述了Swift编程语言的形式语法。这里描述的语法是为了帮助您更详细的了解该语言，而不是让您直接实现一个解析器或编译器。
 
 
 Swift语言相对小点，这是由于在Swift代码中几乎无处不在的许多常见的的类型，函数以及运算符都由Swift标准库来定义。虽然这些类型，函数和运算符不是Swift语言本身的一部分，但是它们被广泛用于这本书的讨论和代码范例。
 
-# 如何阅读语法
+
+## 如何阅读语法
 
 用来描述Swift编程语言形式语法的记法遵循下面几个约定：
 
@@ -31,9 +41,3 @@ Swift语言相对小点，这是由于在Swift代码中几乎无处不在的许
 > 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)­}­
-
-
-================================================================
-上篇：[高级操作符]()
-
-下篇：[词法结构]()
\ No newline at end of file
diff --git a/source/chapter3/02_Lexical_Structure.md b/source/chapter3/02_Lexical_Structure.md
index 0ab9eee4..f60af1a8 100644
--- a/source/chapter3/02_Lexical_Structure.md
+++ b/source/chapter3/02_Lexical_Structure.md
@@ -1,24 +1,30 @@
-# 语法结构
+> 翻译：superkam
+
+> 校对：numbbbbb
+
+# 词法结构
 -----------------
 
 本页包含内容：
 
-- 空白与注释（*Whitespace and Comments*）
-- 标识符（*Identifiers*）
-- 关键字（*Keywords*）
-- 字面量（*Literals*）
-- 运算符（*Operators*）
+- [空白与注释（*Whitespace and Comments*）](#whitespace_and_comments)
+- [标识符（*Identifiers*）](#identifiers)
+- [关键字（*Keywords*）](#keywords)
+- [字面量（*Literals*）](#literals)
+- [运算符（*Operators*）](#operators)
 
-Swift 的“语法结构（*lexical structure*）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。
+Swift 的“词法结构（*lexical structure*）”描述了如何在该语言中用字符序列构建合法标记，组成该语言中最底层的代码块，并在之后的章节中用于描述语言的其他部分。
 
 通常，标记在随后介绍的语法约束下，由 Swift 源文件的输入文本中提取可能的最长子串生成。这种方法称为“最长匹配项（*longest match*）”，或者“最大适合”（*maximal munch*）。
 
+
 ## 空白与注释
 
 空白（*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*）被编译器当作空白处理。单行注释由 `//` 开始直到该行结束。多行注释由 `/*` 开始，以 `*/` 结束。可以嵌套注释，但注意注释标记必须匹配。
 
+
 ## 标识符
 
 标识符（*identifiers*）可以由以下的字符开始：大写或小写的字母 `A` 到 `Z`、下划线 `_`、基本多语言面（*Basic Multilingual Plane*）中的 Unicode 非组合字符以及基本多语言面以外的非专用区（*Private Use Area*）字符。首字符之后，标识符允许使用数字和 Unicode 字符组合。
@@ -28,60 +34,61 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 闭包（*closure*）中如果没有明确指定参数名称，参数将被隐式命名为 $0、$1、$2... 这些命名在闭包作用域内是合法的标识符。
 
 > 标识符语法
-> 
+>
 > *identifier* → [identifier-head­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [identifier-characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters)­ *opt*
-> 
+>
 > *identifier* → \`­ [identifier-head­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [identifier-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) *opt­* \`­
-> 
+>
 > *identifier* → [implicit-parameter-name­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/implicit-parameter-name)
-> 
+>
 > *identifier-list* → [identifier­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [identifier­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) , [­identifier-list](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list)­
-> 
+>
 > *identifier-head* → A 到 Z 大写或小写字母
-> 
+>
 > *identifier-head* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, 或 U+00B7–U+00BA
-> 
+>
 > *identifier-head* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, 或 U+00F8–U+00FF
-> 
+>
 > *identifier-head* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, 或 U+180F–U+1DBF
-> 
+>
 > *identifier-head* → U+1E00–U+1FFF
-> 
+>
 > *identifier-head* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, 或 U+2060–U+206F
-> 
+>
 > *identifier-head* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, 或 U+2776–U+2793
-> 
+>
 > *identifier-head* → U+2C00–U+2DFF 或 U+2E80–U+2FFF
-> 
+>
 > *identifier-head* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, 或 U+3040–U+D7FF
-> 
+>
 > *identifier-head* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, 或 U+FE30–U+FE44
-> 
+>
 > *identifier-head* → U+FE47–U+FFFD
-> 
+>
 > *identifier-head* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, 或 U+40000–U+4FFFD
-> 
+>
 > *identifier-head* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, 或 U+80000–U+8FFFD
-> 
+>
 > *identifier-head* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, 或 U+C0000–U+CFFFD
-> 
+>
 > *identifier-head* → U+D0000–U+DFFFD 或 U+E0000–U+EFFFD
-> 
+>
 > *identifier-character* → 数字 0 到 9
-> 
+>
 > *identifier-character* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
-> 
+>
 > *identifier-character* → [identifier-head­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head)
-> 
+>
 > *identifier-characters* → [identifier-character](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-character) [­identifier-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) *opt­*
-> 
+>
 > *implicit-parameter-name* → **$­** [decimal-digits­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits)
 
+
 ## 关键字
 
 被保留的关键字（*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* 
+* **用作声明的关键字：** *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*
 
@@ -89,6 +96,7 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 
 * **特定上下文中被保留的关键字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、*precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，这些关键字在特定上下文之外可以被用于标识符。
 
+
 ## 字面量
 
 字面值表示整型、浮点型数字或文本类型的值，举例如下：
@@ -98,7 +106,7 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 	"Hello, world!"    // 文本型字面量
 
 > 字面量语法
-> 
+>
 > *literal* → [integer-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/integer-literal) | [floating-point-literal](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-literal)­ | [string-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/string-literal)
 
 ### 整型字面量
@@ -117,47 +125,47 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 除非特殊指定，整型字面量的默认类型为 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)。
 
 > 整型字面量语法
-> 
+>
 > *integer-literal* → [binary-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal)
-> 
+>
 > *integer-literal* → [octal-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal)
-> 
+>
 > *integer-literal* → [decimal-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)
-> 
+>
 > *integer-literal* → [hexadecimal-literal](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)­
-> 
+>
 > *binary-literal* → **0b**­ [binary-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit) ­[binary-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) *opt­*
-> 
+>
 > *binary-digit* → 数字 0 或 1
-> 
+>
 > *binary-literal-character* → [binary-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit)­ | _­
-> 
+>
 > *binary-literal-characters* → [binary-literal-character](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-character) ­[binary-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) *opt­*
-> 
+>
 > *octal-literal* → **0o**­ [octal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit) ­[octal-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) *opt­*
-> 
+>
 > *octal-digit* → 数字 0 至 7
-> 
+>
 > *octal-literal-character* → [octal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit)­ | _­
-> 
+>
 > *octal-literal-characters* → [octal-literal-character](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-character) [­octal-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) *opt­*
-> 
+>
 > *decimal-literal* → [decimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [­decimal-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) *opt­*
-> 
+>
 > *decimal-digit* → 数字 0 至 9
-> 
+>
 > *decimal-digits* → [decimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [decimal-digits­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits) *opt­*
-> 
+>
 > *decimal-literal-character* → [decimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) | _­
-> 
+>
 > *decimal-literal-characters* → [decimal-literal-character](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-character) ­[decimal-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) *opt­*
-> 
+>
 > *hexadecimal-literal* → **0x** ­[hexadecimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [­hexadecimal-literal-characters­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) *opt­*
-> 
+>
 > *hexadecimal-digit* → 数字 0 到 9, a 到 f, 或 A 到 F
-> 
+>
 > *hexadecimal-literal-character* → [hexadecimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)­ | _­
-> 
+>
 > *hexadecimal-literal-characters* → [hexadecimal-literal-character­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-character) [hexadecimal-literal-characters](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) ­*opt­*
 
 ### 浮点型字面量
@@ -176,27 +184,27 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 
 	10_000.56     // 等于 10000.56
 	005000.76     // 等于 5000.76
-	
+
 除非特殊指定，浮点型字面量的默认类型为 Swift 标准库类型中的 `Double`，表示64位浮点数。Swift 标准库也定义 `Float` 类型，表示32位浮点数。
 
 > 浮点型字面量语法
-> 
+>
 > *floating-point-literal* → [decimal-literal](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal) ­[decimal-fraction­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-fraction) *opt* ­[decimal-exponent­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-exponent) *opt­*
-> 
+>
 > *floating-point-literal* → [hexadecimal-literal](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) ­[hexadecimal-fraction](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-fraction) ­*opt­* [hexadecimal-exponent](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-exponent)­
-> 
+>
 > *decimal-fraction* → . [­decimal-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)
-> 
+>
 > *decimal-exponent* → [floating-point-e](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-e) [­sign­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) *opt­* [decimal-literal](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)­
-> 
+>
 > *hexadecimal-fraction* → . [­hexadecimal-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) *opt­*
-> 
+>
 > *hexadecimal-exponent* → [floating-point-p­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-p) [sign­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) *opt­* [hexadecimal-literal­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)
-> 
+>
 > *floating-point-e* → **e­** | **E**­
-> 
+>
 > *floating-point-p* → **p**­ | **P**­
-> 
+>
 > *sign* → **+**­ | **-**­
 
 
@@ -235,29 +243,30 @@ Swift 的“语法结构（*lexical structure*）”描述了如何在该语言
 	"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)。
 
 > 文本型字面量语法
-> 
+>
 > *string-literal* → **"­** [quoted-text](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) **­"­**
-> 
+>
 > *quoted-text* → [quoted-text-item­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text-item) [quoted-text](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) ­*opt­*
-> 
+>
 > *quoted-text-item* → [escaped-character­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/escaped-character)
-> 
+>
 > *quoted-text-item* → **\(**­ [expression­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **)**­
-> 
+>
 > *quoted-text-item* → 除 `"`、`\`­、`U+000A` 或 `U+000D` 以外的任何 Unicode 扩展字符集
-> 
+>
 > *escaped-character* → **\0­** | **\\**­ | **\t­** | **\n**­ | **\r­** | **\"­** | **\'**­
-> 
+>
 > *escaped-character* → **\x­** [hexadecimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)­ [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
-> 
+>
 > *escaped-character* → **\u** ­[hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [­hexadecimal-digit](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)­ [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
-> 
+>
 > *escaped-character* → **\U­** [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [hexadecimal-digit­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
 
+
 ## 运算符
 
 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) 中进行了阐述。这里将描述哪些字符能用作运算符。
@@ -277,20 +286,20 @@ Swift 标准库定义了许多可供使用的运算符，其中大部分在 [基
 
 鉴于这些规则，运算符前的字符 `(`、`[` 和 `{` ；运算符后的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都将用于空白检测。
 
-以上规则需注意一点，如果运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选类型（*optional type*）修饰，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。 
+以上规则需注意一点，如果运算符 `!` 或 `?` 左侧没有空白，则不管右侧是否有空白都将被看作后缀运算符。如果将 `?` 用作可选类型（*optional type*）修饰，左侧必须无空白。如果用于条件运算符 `? :`，必须两侧都有空白。
 
 在特定构成中 ，以 `<` 或 `>` 开头的运算符会被分离成两个或多个标记，剩余部分以同样的方式会被再次分离。因此，在 `Dictionary>` 中没有必要添加空白来消除闭合字符 `>` 的歧义。在这个例子中， 闭合字符 `>` 被看作单字符标记，而不会被误解为移位运算符 `>>`。
 
 要学习如何自定义新的运算符，请参考 [自定义操作符](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* → [operator-character­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator-character) [operator­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) *opt­*
-> 
+>
 > *operator-character* → **/­** | **=­** | **-­** | **+­** | **!­** | ***­** | **%­** | **<­** | **>­** | **&­** | **|­** | **^­** | **~­** | **.­**
-> 
+>
 > *binary-operator* → [operator­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
-> 
+>
 > *prefix-operator* → [operator­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
-> 
-> *postfix-operator* → [operator­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
\ No newline at end of file
+>
+> *postfix-operator* → [operator­](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
diff --git a/source/chapter3/03_Types.md b/source/chapter3/03_Types.md
index 51827579..ea2722c5 100644
--- a/source/chapter3/03_Types.md
+++ b/source/chapter3/03_Types.md
@@ -1,33 +1,38 @@
+> 翻译：lyuka
+
+> 校对：numbbbbb
+
 # 类型（Types）
 -----------------
 
 本页包含内容：
 
--   类型标注（Type Annotation）
--   类型标识符（Type Identifier）
--   元组类型（Tuple Type）
--   函数类型（Function Type）
--   数组类型（Array Type）
--   可选类型（Optional Type）
--   隐式解析可选类型（Implicitly Unwrapped Optional Type）
--   协议合成类型（Protocol Composition Type）
--   元类型（Metatype Type）
--   类型继承子句（Type Inheritance Clause）
--   类型推断（Type Inference）
+-   [类型注解（Type Annotation）](#type_annotation)
+-   [类型标识符（Type Identifier）](#type_identifier)
+-   [元组类型（Tuple Type）](#tuple_type)
+-   [函数类型（Function Type）](#function_type)
+-   [数组类型（Array Type）](#array_type)
+-   [可选类型（Optional Type）](#optional_type)
+-   [隐式解析可选类型（Implicitly Unwrapped Optional Type）](#implicitly_unwrapped_optional_type)
+-   [协议合成类型（Protocol Composition Type）](#protocol_composition_type)
+-   [元类型（Metatype Type）](#metatype_type)
+-   [类型继承子句（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中的类型推断行为。
+本节讨论 Swift 语言本身定义的类型，并描述 Swift 中的类型推断行为。
 
 >类型的语法：
 *type* → *array-type* | *function-type* | *type-identifier* | *tuple-type* | *optional-type* | *implicitly-unwrapped-optional-type* | protocol-composition-type | metatype-type
 
-##类型标注
-类型标注显式地指定一个变量或表达式的值。类型标注始于冒号`:`终于类型，比如下面两个例子：
+
+##类型注解
+类型注解显式地指定一个变量或表达式的值。类型注解始于冒号`:`终于类型，比如下面两个例子：
 
 ```javascript
 let someTuple：(Double, Double) = (3.14159, 2.71828)
@@ -35,11 +40,12 @@ func someFunction(a: Int){ /* ... */ }
 ```
 在第一个例子中，表达式`someTuple`的类型被指定为`(Double, Double)`。在第二个例子中，函数`someFunction`的参数`a`的类型被指定为`Int`。
 
-类型标注可以在类型之前包含一个类型特性（type attributes）的可选列表。
+类型注解可以在类型之前包含一个类型特性（type attributes）的可选列表。
 
->类型标注的语法：
+>类型注解的语法：
 *type-annotation* → :*attributes*[opt] *type*
 
+
 ##类型标识符
 类型标识符引用命名型类型或者是命名型/复合型类型的别名。
 
@@ -62,6 +68,7 @@ var someValue: ExampleModule.MyType
 *type-identifier* → *type-name generic-argument-clause*[opt] | *type-name generic-argument-clause*[opt].*type-identifier*
 *type-name* → *identifier*
 
+
 ##元组类型
 元组类型使用逗号隔开并使用括号括起来的0个或多个类型组成的列表。
 
@@ -72,10 +79,11 @@ var someValue: ExampleModule.MyType
 >元组类型语法：
 *tuple* → (*tuple-type-body*[opt])
 *tuple-type-body* → *tuple-type-element-list* ...[opt]
-*tuple-type-element-list* → *tuple-type-element* | *tuple-type-element*, *tuple-type-element-list* 
-*tuple-type-element* → *attributes*[opt] **inout** [opt] *type* | **inout** [opt] *element-name type-annotation* 
+*tuple-type-element-list* → *tuple-type-element* | *tuple-type-element*, *tuple-type-element-list*
+*tuple-type-element* → *attributes*[opt] **inout** [opt] *type* | **inout** [opt] *element-name type-annotation*
 *element-name* → *identifier*
 
+
 ##函数类型
 函数类型表示一个函数、方法或闭包的类型，它由一个参数类型和返回值类型组成，中间用箭头`->`隔开：
 
@@ -121,6 +129,7 @@ addTwoNumbers(4)(5)     // Returns 9
 >函数类型的语法：
 *function-type* → *type* **->** *type*
 
+
 ##数组类型
 Swift语言使用类型名紧接中括号`[]`来简化标准库中定义的命名型类型`Array`。换句话说，下面两个声明是等价的：
 
@@ -147,6 +156,7 @@ var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
 >数组类型的语法：
 *array-type* → *type*`[ ]` | *array-type*`[ ]`
 
+
 ##可选类型
 Swift定义后缀`?`来作为标准库中的定义的命名型类型`Optional`的简写。换句话说，下面两个声明是等价的：
 
@@ -177,6 +187,7 @@ optionalInteger!      // 42
 >可选类型语法：
 *optional-type* → *type*?
 
+
 ##隐式解析可选类型
 Swift语言定义后缀`!`作为标准库中命名类型`ImplicitlyUnwrappedOptional`的简写。换句话说，下面两个声明等价：
 
@@ -199,8 +210,9 @@ var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional
 >隐式解析可选的语法：
 implicitly-unwrapped-optional-type → type!
 
+
 ##协议合成类型
-协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型标注和泛型参数中。
+协议合成类型是一种符合每个协议的指定协议列表类型。协议合成类型可能会用在类型注解和泛型参数中。
 
 协议合成类型的形式如下：
 ```javascript
@@ -212,9 +224,10 @@ protocol
 
 >协议合成类型的语法：
 *protocol-composition-type* → **protocol** <*protocol-identifier-list[opt]*>
-*protocol-identifier-list* → *protocol-identifier* | *protocol-identifier, protocol-identifier-list* 
+*protocol-identifier-list* → *protocol-identifier* | *protocol-identifier, protocol-identifier-list*
 *protocol-identifier* → *type-identifier*
 
+
 ##元类型
 元类型是指所有类型的类型，包括类、结构体、枚举和协议。
 
@@ -243,6 +256,7 @@ someInstance.dynamicType.printClassName()
 >元类型的语法：
 *metatype-type* → *type*.**Type** | *type*.**Protocol**
 
+
 ##类型继承子句
 类型继承子句被用来指定一个命名型类型继承哪个类且适配哪些协议。类型继承子句开始于冒号`:`，紧跟由`,`隔开的类型标识符列表。
 
@@ -253,19 +267,20 @@ someInstance.dynamicType.printClassName()
 枚举定义中的类型继承子句可以是一个协议列表，或是指定原始值的枚举，一个单独的指定原始值类型的命名型类型。使用类型继承子句来指定原始值类型的枚举定义的例子，见章节“原始值”。
 
 >类型继承子句的语法：
-*type-inheritance-clause* → :*type-inheritance-list* 
+*type-inheritance-clause* → :*type-inheritance-list*
 *type-inheritance-list* → *type-identifier* | *type-identifier*, *type-inheritance-list*
 
+
 ##类型推断
 Swift广泛的使用类型推断，从而允许你可以忽略很多变量和表达式的类型或部分类型。比如，对于`var x: Int = 0`，你可以完全忽略类型而简写成`var x = 0`——编译器会正确的推断出`x`的类型`Int`。类似的，当完整的类型可以从上下文推断出来时，你也可以忽略类型的一部分。比如，如果你写了`let dict: Dictionary = ["A": 1]`，编译提也能推断出`dict`的类型是`Dictionary`。
 
 在上面的两个例子中，类型信息从表达式树（expression tree）的叶子节点传向根节点。也就是说，`var x: Int = 0`中`x`的类型首先根据`0`的类型进行推断，然后将该类型信息传递到根节点（变量`x`）。
 
-在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量`eFloat`上的显式类型标注（`:Float`）导致数字字面量`2.71828`的类型是`Float`而非`Double`。
+在Swift中，类型信息也可以反方向流动——从根节点传向叶子节点。在下面的例子中，常量`eFloat`上的显式类型注解（`:Float`）导致数字字面量`2.71828`的类型是`Float`而非`Double`。
 
 ```javascript
 let e = 2.71828 // The type of e is inferred to be Double.
 let eFloat: Float = 2.71828 // The type of eFloat is Float.
 ```
 
-Swift中的类型推断在单独的表达式或语句水平上进行。这意味着所有用于推断类型的信息必须可以从表达式或其某个子表达式的类型检查中获取。
\ No newline at end of file
+Swift中的类型推断在单独的表达式或语句水平上进行。这意味着所有用于推断类型的信息必须可以从表达式或其某个子表达式的类型检查中获取。
diff --git a/source/chapter3/04_Expressions.md b/source/chapter3/04_Expressions.md
index 9ba92787..3635909c 100644
--- a/source/chapter3/04_Expressions.md
+++ b/source/chapter3/04_Expressions.md
@@ -1,27 +1,41 @@
-# 表达式(Expressions)
+> 翻译：sg552
+
+> 校对：numbbbbb
+
+# 表达式（Expressions）
 -----------------
 
-Swift 中存在四种表达式： 前缀(prefix)表达式，二元(binary)表达式，主要(primary)表达式和后缀(postfix)表达式。表达式可以返回一个值，以及运行某些逻辑(causes a side effect)。
+本页包含内容：
 
-前缀表达式和二元表达式就是对某些表达式使用各种运算符(operators)。 主要表达式是最短小的表达式，它提供了获取(变量的)值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～
+- [前缀表达式（Prefix Expressions）]
+- [二元表达式（Binary Expressions）]
+- [赋值表达式（Assignment Operator）]
+- [三元条件运算符（Ternary Conditional Operator）]
+- [类型转换运算符（Type-Casting Operators）]
+- [主要表达式（Primary Expressions）]
+- [后缀表达式（Postfix Expressions）]
+
+Swift 中存在四种表达式： 前缀（prefix）表达式，二元（binary）表达式，主要（primary）表达式和后缀（postfix）表达式。表达式可以返回一个值，以及运行某些逻辑（causes a side effect）。
+
+前缀表达式和二元表达式就是对某些表达式使用各种运算符（operators）。 主要表达式是最短小的表达式，它提供了获取（变量的）值的一种途径。 后缀表达式则允许你建立复杂的表达式，例如配合函数调用和成员访问。 每种表达式都在下面有详细论述～
 
 > 表达式的语法
 >
-> *expression* → *prefix-expression*­*binary-expressions*(opt)
+> *expression* → *prefix-expression*­*binary-expressions(*opt)
 > *expression-list* → *expression*­| *expression*­,­*expression-list*
 
-## 前缀表达式(Prefix Expressions)
+## 前缀表达式（Prefix Expressions）
 
-前缀表达式由 前缀符号和表达式组成。(这个前缀符号只能接收一个参数)
+前缀表达式由 前缀符号和表达式组成。（这个前缀符号只能接收一个参数）
 
 Swift 标准库支持如下的前缀操作符：
 
-- ++ 自增1 (increment)
-- -- 自减1 (decrement)
-- ! 逻辑否 (Logical NOT )
-- ~ 按位否 (Bitwise NOT )
-- \+ 加(Unary plus)
-- \- 减(Unary minus)
+- ++ 自增1 （increment）
+- -- 自减1 （decrement）
+- ! 逻辑否 （Logical NOT ）
+- ~ 按位否 （Bitwise NOT ）
+- \+ 加（Unary plus）
+- \- 减（Unary minus）
 
 对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
 
@@ -33,7 +47,7 @@ Swift 标准库支持如下的前缀操作符：
 > *prefix-expression* → *in-out-expression*­
 > *in-out-expression* → &­*identifier*­
 
-## 二元表达式( Binary Expressions)
+## 二元表达式（Binary Expressions）
 
 二元表达式由 "左边参数" + "二元运算符" + "右边参数" 组成, 它有如下的形式：
 
@@ -42,30 +56,30 @@ Swift 标准库支持如下的前缀操作符：
 Swift 标准库提供了如下的二元运算符：
 
 - 求幂相关（无结合，优先级160）
-  - << 按位左移(Bitwise left shift)
-  - >> 按位右移(Bitwise right shift)
+  - << 按位左移（Bitwise left shift）
+  - >> 按位右移（Bitwise right shift）
 - 乘除法相关（左结合，优先级150）
   - \* 乘
   - / 除
   - % 求余
-  - &* 乘法，忽略溢出( Multiply, ignoring overflow)
-  - &/ 除法，忽略溢出(Divide, ignoring overflow)
-  - &% 求余, 忽略溢出( Remainder, ignoring overflow)
-  - & 位与( Bitwise AND)
-- 加减法相关(左结合, 优先级140)
+  - &* 乘法，忽略溢出（ Multiply, ignoring overflow）
+  - &/ 除法，忽略溢出（Divide, ignoring overflow）
+  - &% 求余, 忽略溢出（ Remainder, ignoring overflow）
+  - & 位与（ Bitwise AND）
+- 加减法相关（左结合, 优先级140）
   - \+ 加
   - \- 减
   - &+ Add with overflow
   - &- Subtract with overflow
-  - | 按位或(Bitwise OR )
-  - ^ 按位异或(Bitwise XOR)
-- Range (无结合,优先级 135)
+  - | 按位或（Bitwise OR ）
+  - ^ 按位异或（Bitwise XOR）
+- Range （无结合,优先级 135）
   - .. 半闭值域 Half-closed range
   - ... 全闭值域 Closed range
-- 类型转换 (无结合,优先级 132)
-  - is 类型检查( type check)
-  - as 类型转换( type cast)
-- Comparative (无结合,优先级 130)
+- 类型转换 （无结合,优先级 132）
+  - is 类型检查（ type check）
+  - as 类型转换（ type cast）
+- Comparative （无结合,优先级 130）
   - < 小于
   - <= 小于等于
   - > 大于
@@ -74,15 +88,15 @@ Swift 标准库提供了如下的二元运算符：
   - != 不等
   - === 恒等于
   - !== 不恒等
-  - ~= 模式匹配( Pattern match)
-- 合取( Conjunctive) (左结合,优先级 120)
-  - && 逻辑与(Logical AND)
-- 析取(Disjunctive) (左结合,优先级 110)
-  - || 逻辑或( Logical OR)
-- 三元条件(Ternary Conditional )(右结合,优先级 100)
+  - ~= 模式匹配（ Pattern match）
+- 合取（ Conjunctive） （左结合,优先级 120）
+  - && 逻辑与（Logical AND）
+- 析取（Disjunctive） （左结合,优先级 110）
+  - || 逻辑或（ Logical OR）
+- 三元条件（Ternary Conditional ）（右结合,优先级 100）
   - ?: 三元条件 Ternary conditional
-- 赋值 (Assignment) (右结合, 优先级 90)
-  - = 赋值(Assign)
+- 赋值 （Assignment） （右结合, 优先级 90）
+  - = 赋值（Assign）
   - *=  Multiply and assign
   - /= Divide and assign
   - %= Remainder and assign
@@ -96,11 +110,11 @@ Swift 标准库提供了如下的二元运算符：
   - &&= Logical AND and assign
   - ||= Logical OR and assign
 
-关于这些运算符(operators)的更多信息，请参见：Basic Operators and Advanced Operators.
+关于这些运算符（operators）的更多信息，请参见：Basic Operators and Advanced Operators.
 
 >> 注意
 >>
->> 在解析时,  一个二元表达式表示为一个一级数组(a flat list), 这个数组(List)根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是：  2, + , `` 3``, *, 5. 随后它被转换成 tree (2 + (3 * 5))
+>> 在解析时,  一个二元表达式表示为一个一级数组（a flat list）, 这个数组（List）根据运算符的先后顺序，被转换成了一个tree. 例如： 2 + 3 * 5 首先被认为是：  2, + , `` 3``, *, 5. 随后它被转换成 tree （2 + （3 * 5））
 
 > 二元表达式的语法
 >
@@ -108,16 +122,16 @@ Swift 标准库提供了如下的二元运算符：
 > *binary-expression* → *assignment-operator*­prefix-expression*
 > *binary-expression* → *conditional-operator*­prefix-expression*
 > *binary-expression* → *type-casting-operator*­
-> *binary-expression*s → *binary-expression*­*binary-expressions*(opt­)
+> *binary-expression*s → *binary-expression*­*binary-expressions*(opt)
 
-## 赋值表达式( Assignment Operator)
+## 赋值表达式（Assignment Operator）
 
 The assigment operator sets a new value for a given expression. It has the following form:
 赋值表达式会对某个给定的表达式赋值。 它有如下的形式；
 
 `expression` = `value`
 
-就是把右边的 *value* 赋值给左边的 *expression*. 如果左边的*expression* 需要接收多个参数（是一个tuple )，那么右边必须也是一个具有同样数量参数的tuple. (允许嵌套的tuple)
+就是把右边的 *value* 赋值给左边的 *expression*. 如果左边的*expression* 需要接收多个参数（是一个tuple ），那么右边必须也是一个具有同样数量参数的tuple. （允许嵌套的tuple）
 
 ```swift
 (a, _, (b, c)) = ("test", 9.45, (12, 3))
@@ -130,13 +144,13 @@ The assigment operator sets a new value for a given expression. It has the follo
 >
 > *assignment-operator* → =­
 
-## 三元条件运算符(Ternary Conditional Operator)
+## 三元条件运算符（Ternary Conditional Operator）
 
 三元条件运算符 是根据条件来获取值。 形式如下：
 
     `condition` ? `expression used if true` : `expression used if false`
 
-如果 `condition` 是true, 那么返回 第一个表达式的值(此时不会调用第二个表达式）， 否则返回第二个表达式的值(此时不会调用第一个表达式）。
+如果 `condition` 是true, 那么返回 第一个表达式的值（此时不会调用第二个表达式）， 否则返回第二个表达式的值（此时不会调用第一个表达式）。
 
 想看三元条件运算符的例子，请参见： Ternary Conditional Operator.
 
@@ -144,7 +158,7 @@ The assigment operator sets a new value for a given expression. It has the follo
 >
 > `conditional-operator` → ?­`expression`­:­
 
-## 类型转换运算符(Type-Casting Operators)
+## 类型转换运算符（Type-Casting Operators）
 
 有两种类型转换操作符： as 和 is.  它们有如下的形式：
 
@@ -152,13 +166,13 @@ The assigment operator sets a new value for a given expression. It has the follo
     `expression` as? `type`
     `expression` is `type`
 
-as 运算符会把`目标表达式`转换成指定的`类型`(specified type)，过程如下：
+as 运算符会把`目标表达式`转换成指定的`类型`（specified type），过程如下：
 
-- 如果类型转换成功， 那么目标表达式就会返回指定类型的实例(instance). 例如：把子类(subclass)变成父类(superclass)时.
+- 如果类型转换成功， 那么目标表达式就会返回指定类型的实例（instance）. 例如：把子类（subclass）变成父类（superclass）时.
 
-- 如果转换失败，则会抛出编译错误( compile-time error)。
+- 如果转换失败，则会抛出编译错误（ compile-time error）。
 
-- 如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，) 那么目标表达式就会变成指定的类型的optional. (is an optional of the specified type ) 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.
+- 如果上述两个情况都不是（也就是说，编译器在编译时期无法确定转换能否成功，） 那么目标表达式就会变成指定的类型的optional. （is an optional of the specified type ） 然后在运行时，如果转换成功， 目标表达式就会作为 optional的一部分来返回， 否则，目标表达式返回nil. 对应的例子是： 把一个 superclass 转换成一个 subclass.
 
 ```swift
 class SomeSuperType {}
@@ -178,10 +192,10 @@ let y1 = x as SomeType  // Type information from 'as'
 let y2: SomeType = x    // Type information from an annotation
 ```
 
-'is' 运算符在“运行时(runtime)”会做检查。 成功会返回true, 否则 false
+'is' 运算符在“运行时（runtime）”会做检查。 成功会返回true, 否则 false
 
 The check must not be known to be true or false at compile time. The following are invalid:
-上述检查在“编译时(compile time)”不能使用。 例如下面的使用是错误的：
+上述检查在“编译时（compile time）”不能使用。 例如下面的使用是错误的：
 
 ```swift
 "hello" is String
@@ -194,13 +208,13 @@ The check must not be known to be true or false at compile time. The following a
 >
 > *type-casting-operator* → is­*type*­| as­?(opt)­*type*
 
-## 主要表达式(Primary Expressions)
+## 主要表达式（Primary Expressions）
 
 `主要表达式`是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。
 
 > 主要表达式的语法
 >
-> *primary-expression* → *identifier*­*generic-argument-clause*­(opt)
+> *primary-expression* → *identifier*­*generic-argument-clause*(opt)
 > *primary-expression* → *literal-expression*­
 > *primary-expression* → *self-expression*­
 > *primary-expression* → *superclass-expression*­
@@ -209,30 +223,30 @@ The check must not be known to be true or false at compile time. The following a
 > *primary-expression* → *implicit-member-expression*
 > *primary-expression* → *wildcard-expression*
 
-### 字符型表达式(Literal Expression)
+### 字符型表达式（Literal Expression）
 
-由这些内容组成：普通的字符（string, number) , 一个字符的字典或者数组，或者下面列表中的特殊字符。
+由这些内容组成：普通的字符（string, number） , 一个字符的字典或者数组，或者下面列表中的特殊字符。
 
-字符(Literal) | 类型(Type) | 值(Value)
+字符（Literal） | 类型（Type） | 值（Value）
 ------------- | ---------- | ----------
 \__FILE__ | String | 所在的文件名
 \__LINE__ | Int | 所在的行数
 \__COLUMN__ | Int | 所在的列数
 \__FUNCTION__ | String | 所在的function 的名字
 
-在某个函数(function)中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法(method)中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员(member)中会返回这个keyword的名字，在某个文件的顶端(the top level of a file)，它返回的是当前module的名字。
+在某个函数（function）中，`__FUNCTION__` 会返回当前函数的名字。 在某个方法（method）中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员（member）中会返回这个keyword的名字，在某个文件的顶端（the top level of a file），它返回的是当前module的名字。
 
 一个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.（closest common supertype）
 
-一个`dictionary literal` 是一个包含无序的键值对(key-value pairs)的集合，它的形式是:
+一个`dictionary literal` 是一个包含无序的键值对（key-value pairs）的集合，它的形式是:
 
     [`key 1`: `value 1`, `key 2`: `value 2`, `...`]
 
-dictionary 的最后一个表达式可以是一个逗号(','). [:] 表示一个空的dictionary. 它的type是 Dictionary (这里KeyType表示 key的type, ValueType表示 value的type) 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type( closest common supertype).
+dictionary 的最后一个表达式可以是一个逗号（','）. [:] 表示一个空的dictionary. 它的type是 Dictionary （这里KeyType表示 key的type, ValueType表示 value的type） 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type（ closest common supertype）.
 
 > 字符型表达式的语法
 >
@@ -246,25 +260,25 @@ dictionary 的最后一个表达式可以是一个逗号(','). [:] 表示一个
 > *dictionary-literal-items*  → *dictionary-literal-item*,­(opt)­| *dictionary-literal-item*­,­*dictionary-literal-items*­
 > *dictionary-literal-item*  → *expression*­:­*expression*­
 
-### self表达式(Self Expression)
+### self表达式（Self Expression）
 
 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.
+如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法（static method）, 类方法（class method）中， self等同于当前的type.
 
-当访问 member（成员变量时）， self 用来区分重名变量(例如函数的参数).  例如，
-(下面的 self.greeting 指的是 var greeting: String, 而不是 init(greeting: String) )
+当访问 member（成员变量时）， self 用来区分重名变量（例如函数的参数）.  例如，
+（下面的 self.greeting 指的是 var greeting: String, 而不是 init（greeting: String） ）
 
 ```swift
 class SomeClass {
     var greeting: String
-    init(greeting: String) {
+    init（greeting: String） {
         self.greeting = greeting
     }
 }
@@ -275,8 +289,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）
     }
 }
 ```
@@ -288,17 +302,17 @@ struct Point {
 > *self-expression* → self­[­*expression*­]­
 > *self-expression* → self­.­init­
 
-### 超类表达式(Superclass Expression)
+### 超类表达式（Superclass Expression）
 
 超类表达式可以使我们在某个class中访问它的超类. 它有如下形式：
 
     super.`member name`
     super[`subscript index`]
-    super.init(`initializer arguments`)
+    super.init（`initializer arguments`）
 
-形式1 用来访问超类的某个成员(member). 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.
+形式1 用来访问超类的某个成员（member）. 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.
 
-子类(subclass)可以通过超类(superclass)表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现(既有的方法或者逻辑)。
+子类（subclass）可以通过超类（superclass）表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现（既有的方法或者逻辑）。
 
 > GRAMMAR OF A SUPERCLASS EXPRESSION
 
@@ -307,12 +321,12 @@ struct Point {
 > *superclass-subscript-expression* → super­[­*expression*­]­
 > *superclass-initializer-expression* → super­.­init­
 
-### 闭包表达式(Closure Expression)
+### 闭包表达式（Closure Expression）
 
-闭包(closure) 表达式可以建立一个闭包(在其他语言中也叫 lambda, 或者 匿名函数(anonymous function)). 跟函数(function)的声明一样， 闭包(closure)包含了可执行的代码(跟方法主体(statement)类似） 以及接收(capture)的参数。 它的形式如下：
+闭包（closure） 表达式可以建立一个闭包（在其他语言中也叫 lambda, 或者 匿名函数（anonymous function））. 跟函数（function）的声明一样， 闭包（closure）包含了可执行的代码（跟方法主体（statement）类似） 以及接收（capture）的参数。 它的形式如下：
 
 ```swift
-  { (parameters) -> return type in
+  { （parameters） -> return type in
       statements
   }
 ```
@@ -321,20 +335,20 @@ struct Point {
 
 闭包还有几种特殊的形式, 让使用更加简洁：
 
-- 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知(inferred) ，那么就会抛出编译错误。
-- 闭包可以省略参数，转而在方法体(statement)中使用 $0, $1, $2 来引用出现的第一个，第二个，第三个参数。
+- 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知（inferred） ，那么就会抛出编译错误。
+- 闭包可以省略参数，转而在方法体（statement）中使用 $0, $1, $2 来引用出现的第一个，第二个，第三个参数。
 - 如果闭包中只包含了一个表达式，那么该表达式就会自动成为该闭包的返回值。 在执行 'type inference '时，该表达式也会返回。
 
 下面几个 闭包表达式是 等价的：
 
 ```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
 }
 
@@ -345,21 +359,21 @@ myFunction { $0 + $1 }
 
 关于 向闭包中传递参数的内容，参见： Function Call Expression.
 
-闭包表达式可以通过一个参数列表(capture list) 来显式指定它需要的参数。 参数列表 由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字(在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。
+闭包表达式可以通过一个参数列表（capture list） 来显式指定它需要的参数。 参数列表 由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字（在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等）。
 
-在闭包的参数列表( capture list)中， 参数可以声明为 'weak' 或者 'unowned' .
+在闭包的参数列表（ 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. ) 例如：
+在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取（这句话请慎重理解）。（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.
@@ -373,11 +387,11 @@ myFunction { [weak parent = self.parent] in print(parent!.title) }
 > *closure-signature* →  *capture-list*­*identifier-list*­*function-result*­(opt)­in­
 > *closure-signature* →  *capture-list*­in­
 > *capture-list* → [­*capture-specifier*­*expression*­]­
-> *capture-specifier* → weak­| unowned­| unowned(safe)­| unowned(unsafe)­
+> *capture-specifier* → weak­| unowned­| unowned（safe）­| unowned（unsafe）­
 
-### 隐式成员表达式(Implicit Member Expression)
+### 隐式成员表达式（Implicit Member Expression）
 
-在可以判断出类型(type)的上下文(context)中，隐式成员表达式是访问某个type的member( 例如 class method, enumeration case) 的简洁方法。 它的形式是：
+在可以判断出类型（type）的上下文（context）中，隐式成员表达式是访问某个type的member（ 例如 class method, enumeration case） 的简洁方法。 它的形式是：
 
 .`member name`
 
@@ -392,26 +406,26 @@ x = .AnotherValue
 >
 >  *implicit-member-expression* → .­*identifier*
 
-### 圆括号表达式(Parenthesized Expression)
+### 圆括号表达式（Parenthesized Expression）
 
 圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：
 
-(`identifier 1`: `expression 1`, `identifier 2`: `expression 2`, `...`)
+（`identifier 1`: `expression 1`, `identifier 2`: `expression 2`, `...`）
 
-圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： (1)的 type是Int, 而不是(Int)
+圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： （1）的 type是Int, 而不是（Int）
 
 > 圆括号表达式的语法
 >
-> *parenthesized-expression* → (­*expression-element-list* (opt)­)­
+> *parenthesized-expression* → （­*expression-element-list* (opt)­）­
 > *expression-element-list* → *expression-element*­| *expression-element*­,­*expression-element-list*­
 > *expression-element* → *expression*­| *identifier*­:­*expression*
 
-### 通配符表达式( Wildcard Expression)
+### 通配符表达式（Wildcard Expression）
 
 通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略（译注：好奇葩的语法。。。）
 
 ```swift
-(x, _) = (10, 20)
+（x, _） = （10, 20）
 // x is 10, 20 is ignored
 ```
 
@@ -419,9 +433,9 @@ x = .AnotherValue
 >
 > *wildcard-expression* → _­
 
-## 后缀表达式( Postfix Expressions)
+## 后缀表达式（Postfix Expressions）
 
-后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式(primary expression)都是一个后缀表达式
+后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式（primary expression）都是一个后缀表达式
 
 Swift 标准库提供了下列后缀表达式：
 
@@ -443,32 +457,32 @@ Swift 标准库提供了下列后缀表达式：
 > *postfix-expression* → *forced-value-expression*­
 > *postfix-expression* → *optional-chaining-expression*­
 
-### 函数调用表达式( Function Call Expression)
+### 函数调用表达式（Function Call Expression）
 
 函数调用表达式由函数名和参数列表组成。它的形式如下：
 
-`function name`(`argument value 1`, `argument value 2`)
+`function name`（`argument value 1`, `argument value 2`）
 
 The function name can be any expression whose value is of a function type.
-(不用翻译了, 太罗嗦）
+（不用翻译了, 太罗嗦）
 
 如果该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) ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
+可以在 函数调用表达式的尾部（最后一个参数之后）加上 一个闭包（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}
 ```
 
@@ -478,26 +492,26 @@ myData.someMethod {$0 == 13}
 > *function-call-expression* → *postfix-expression*­*parenthesized-expression*­(opt)­*trailing-closure*­
 > *trailing-closure* → *closure-expression*­
 
-### 初始化函数表达式(Initializer Expression)
+### 初始化函数表达式（Initializer Expression）
 
 Initializer表达式用来给某个Type初始化。 它的形式如下：
 
-`expression`.init(`initializer arguments`)
+`expression`.init（`initializer arguments`）
 
-(Initializer表达式用来给某个Type初始化。) 跟函数(function)不同， initializer 不能返回值。
+（Initializer表达式用来给某个Type初始化。） 跟函数（function）不同， initializer 不能返回值。
 
 ```swift
 var x = SomeClass.someClassFunction // ok
 var y = SomeClass.init              // error
 ```swift
 
-可以通过 initializer 表达式来委托调用(delegate to )到superclass的initializers.
+可以通过 initializer 表达式来委托调用（delegate to ）到superclass的initializers.
 
 ```swift
 class SomeSubClass: SomeSuperClass {
-    init() {
+    init（） {
         // subclass initialization goes here
-        super.init()
+        super.init（）
     }
 }
 ```
@@ -506,39 +520,39 @@ class SomeSubClass: SomeSuperClass {
 >
 > *initializer-expression* → *postfix-expression*­.­init­
 
-### 显式成员表达式(Explicit Member Expression)
+### 显式成员表达式（Explicit Member Expression）
 
 显示成员表达式允许我们访问type, tuple, module的成员变量。它的形式如下：
 
 `expression`.`member name`
 
-该member 就是某个type在声明时候所定义(declaration or extension) 的变量, 例如：
+该member 就是某个type在声明时候所定义（declaration or extension） 的变量, 例如：
 
 ```swift
 class SomeClass {
     var someProperty = 42
 }
-let c = SomeClass()
+let c = SomeClass（）
 let y = c.someProperty  // Member access
 ```
 
-对于tuple, 要根据它们出现的顺序(0, 1, 2...)来使用:
+对于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）
 ```
 
 The members of a module access the top-level declarations of that module.
-(不确定：对于某个module的member的调用，只能调用在top-level声明中的member.)
+（不确定：对于某个module的member的调用，只能调用在top-level声明中的member.）
 
 > 显示成员表达式的语法
 >
 > *explicit-member-expression* → *postfix-expression*­.­*decimal-digit*­
 > *explicit-member-expression* → *postfix-expression*­.­*identifier*­*generic-argument-clause*(opt)
 
-### 后缀self表达式(Postfix Self Expression)
+### 后缀self表达式（Postfix Self Expression）
 
 后缀表达式由 某个表达式 + '.self' 组成. 形式如下：
 
@@ -553,32 +567,32 @@ The members of a module access the top-level declarations of that module.
 >
 > *postfix-self-expression* → *postfix-expression*­.­self­
 
-### dynamic表达式(Dynamic Type Expression)
+### dynamic表达式（Dynamic Type Expression）
 
-(因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression)
+（因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression）
 
 dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。
 
 `expression`.dynamicType
 
-上面的形式中， expression 不能是某type的名字(当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子：
+上面的形式中， expression 不能是某type的名字（当然了，如果我都知道它的名字了还需要动态来获取它吗）。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子：
 
 ```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"
 ```
 
@@ -586,33 +600,33 @@ someInstance.dynamicType.printClassName()
 >
 > *dynamic-type-expression* → *postfix-expression*­.­dynamicType­
 
-### 下标表达式( Subscript Expression)
+### 附属脚本表达式（Subscript Expression）
 
-下标表达式提供了通过下标访问getter/setter 的方法。它的形式是：
+附属脚本表达式提供了通过附属脚本访问getter/setter 的方法。它的形式是：
 
 `expression`[`index expressions`]
 
-可以通过下标表达式通过getter获取某个值，或者通过setter赋予某个值.
+可以通过附属脚本表达式通过getter获取某个值，或者通过setter赋予某个值.
 
 关于subscript的声明，请参见： Protocol Subscript Declaration.
 
-> 下标表达式的语法
+> 附属脚本表达式的语法
 >
 > *subscript-expression* → *postfix-expression*­[­*expression-list*­]­
 
-### 强制取值表达式(Forced-Value Expression)
+### 强制取值表达式（Forced-Value Expression）
 
-强制取值表达式用来获取某个目标表达式的值(该目标表达式的值必须不是nil )。它的形式如下：
+强制取值表达式用来获取某个目标表达式的值（该目标表达式的值必须不是nil ）。它的形式如下：
 
 `expression`!
 
-如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误(runtime error)。
+如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误（runtime error）。
 
 > 强制取值表达式的语法
 >
 > *forced-value-expression* → *postfix-expression*­!­
 
-### 可选链表达式(Optional-Chaining Expression)
+### 可选链表达式（Optional-Chaining Expression）
 
 可选链表达式由目标表达式 + '?' 组成，形式如下：
 
@@ -620,20 +634,20 @@ someInstance.dynamicType.printClassName()
 
 后缀'?' 返回目标表达式的值，把它做为可选的参数传递给后续的表达式
 
-如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值(依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type(In either case, the value of the postfix expression is still of an optional type)
+如果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值（依次执行它的各个子表达式）。在这两种情况下，该后缀表达式仍然是一个optional type（In either case, the value of the postfix expression is still of an optional type）
 
-如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction() 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction()方法。 然后对于 "c?.property.performAction()" 这个整体，它的返回值是一个optional type.
+如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction（） 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction（）方法。 然后对于 "c?.property.performAction（）" 这个整体，它的返回值是一个optional type.
 
 ```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（）
 }
 ```
 
diff --git a/source/chapter3/05_Declarations.md b/source/chapter3/05_Declarations.md
index e69de29b..e928c346 100644
--- a/source/chapter3/05_Declarations.md
+++ b/source/chapter3/05_Declarations.md
@@ -0,0 +1,902 @@
+> 翻译：marsprince
+
+> 校对：numbbbbb
+
+# 声明
+ -----------------
+
+本页包含内容：
+
+- [模块范围](#module_scope)
+- [代码块](#code_blocks)
+- [引入声明](#import_declaration)
+- [常量声明](#constant_declaration)
+- [变量声明](#variable_declaration)
+- [类型的别名声明](#type_alias_declaration)
+- [函数声明](#function_declaration)
+- [枚举声明](#enumeration_declaration)
+- [结构体声明](#structure_declaration)
+- [类声明](#class_declaration)
+- [协议声明](#protocol_declaration)
+- [构造器声明](#initializer_declaration)
+- [析构声明](#deinitializer_declaration)
+- [扩展声明](#extension_declaration)
+- [附属脚本声明](#subscript_declaration)
+- [运算符声明](#operator_declaration)
+
+一条声明可以在你的程序里引入新的名字和构造。举例来说，你可以使用声明来引入函数和方法，变量和常量，或者来定义
+新的命名好的枚举，结构，类和协议类型。你也可以使用一条声明来延长一个已经存在的命名好的类型的行为。或者在你的
+程序里引入在其他地方声明的符号。
+
+在swift中，大多数声明在某种意义上讲也是执行或同事声明它们的初始化定义。这意味着，因为协议和他们的成员不匹配，
+大多数协议成员需要单独的声明。为了方便起见，也因为这些区别在swift里不是很重要，声明语句同时包含了声明和定义。
+
+>GRAMMAR OF A DECLARATION
+
+>declaration → import-declaration­
+
+>declaration → constant-declaration­
+
+>declaration → variable-declaration­
+
+>declaration → typealias-declaration­
+
+>declaration → function-declaration­
+
+>declaration → enum-declaration­
+
+>declaration → struct-declaration­
+
+>declaration → class-declaration­
+
+>declaration → protocol-declaration­
+
+> declaration → initializer-declaration­
+
+>declaration → deinitializer-declaration­
+
+> declaration → extension-declaration­
+
+> declaration → subscript-declaration­
+
+>declaration → operator-declaration­
+
+>declarations → declaration­declarations­opt­
+
+>declaration-specifiers → declaration-specifier­declaration-specifiers­opt­
+
+>declaration-specifier → class­ | mutating ­| nonmutating­ | override­ | static­ | unowned |
+
+
+##模块范围
+
+模块范围定义了对模块中其他源文件可见的代码。（注：待改进）在swift的源文件中，最高级别的代码由零个或多个语句，
+声明和表达组成。变量，常量和其他的声明语句在一个源文件的最顶级被声明，使得他们对同一模块中的每个源文件都是可见的。
+
+>GRAMMAR OF A TOP-LEVEL DECLARATION
+
+>top-level-declaration → statements ­opt
+
+
+##代码块
+
+代码块用来将一些声明和控制结构的语句组织在一起。它有如下的形式：
+
+    {
+        `statements`
+    }
+
+代码块中的语句包括声明，表达式和各种其他类型的语句，它们按照在源码中的出现顺序被依次执行。
+
+>GRAMMAR OF A CODE BLOCK
+
+>code-block → ­statements ­opt­
+
+
+##引入声明
+
+引入声明使你可以使用在其他文件中声明的内容。引入语句的基本形式是引入整个代码模块；它由import关键字开始，后面
+紧跟一个模块名：
+
+    import  module
+
+你可以提供更多的细节来限制引入的符号，如声明一个特殊的子模块或者在一个模块或子模块中做特殊的声明。（待改进）
+当你使用了这些细节后，在当前的程序汇总只有引入的符号是可用的（并不是声明的整个模块）。
+
+    import import kind module.symbol name
+    import module.submodule
+
+>GRAMMAR OF AN IMPORT DECLARATION
+
+>import-declaration → attributes ­opt ­import­ import-kind­ opt import-path­
+>import-kind → typealias­ | struct­ | class­ | enum­ | protocol­ | var­ | func­
+>import-path → import-path-identifier­  import-path-identifier­.­import-path­
+>import-path-identifier → identifier­  operator
+
+
+##常量声明
+
+常量声明可以在你的程序里命名一个常量。常量以关键词let来声明，遵循如下的格式:
+
+    let constant name: type = expression
+
+当常量的值被给定后，常量就将常量名称和表达式初始值不变的结合在了一起，而且不能更改。
+这意味着如果常量以类的形式被初始化，类本身的内容是可以改变的，但是常量和类之间的结合关系是不能改变的。
+当一个常量被声明为全局变量，它必须被给定一个初始值。当一个常量在类或者结构体中被声明时，他被认为是一个常量
+属性。常量并不是可计算的属性，因此不包含getters和setters。（译者注：getters和setters不知道怎么翻译，待改进）
+
+如果常量名是一个元祖形式，元祖中的每一项初始化表达式中都要有对应的值
+
+    let (firstNumber, secondNumber) = (10, 42)
+
+在上例中，firstNumber是一个值为10的常量，secnodeName是一个值为42的常量。所有常量都可以独立的使用：
+
+    1  println("The first number is \(firstNumber).")
+    2  // prints "The first number is 10."
+    3  println("The second number is \(secondNumber).")
+    4  // prints "The second number is 42."
+
+类型注释（:type）在常量声明中是一个可选项，它可以用来描述在类型接口（type inference）中找到的类型。
+
+声明一个静态常量要使用关键字static。静态属性在类型属性（type propetries）中有介绍。
+
+如果还想获得更多关于常量的信息或者想在使用中获得帮助，请查看常量和变量（constants and variables）,
+存储属性（stored properties）等节。
+
+>GRAMMAR OF A CONSTANT DECLARATION
+
+>constant-declaration → attributes­ opt ­declaration-specifiers­ opt ­let­pattern-initializer-list­
+>pattern-initializer-list → pattern-initializer­ | pattern-initializer­ , pattern-initializer-list­
+>pattern-initializer → pattern ­initializer ­opt­
+>initializer → =­expression
+
+
+##变量声明
+
+变量声明可以在你的程序里声明一个变量，它以关键字var来声明。根据声明变量类型和值的不同，如存储和计算
+变量和属性，存储变量和属性监视，和静态变量属性，有着不同的声明形式。（待改进）
+所使用的声明形式取决于变量所声明的范围和你打算声明的变量类型。
+
+>注意：
+>
+你也可以在协议声明的上下文声明属性，详情参见类型属性声明。
+
+###存储型变量和存储型属性
+
+下面的形式声明了一个存储型变量或存储型变量属性
+
+    var variable name: type = expression
+
+你可以在全局，函数内，或者在类和结构体的声明(context)中使用这种形式来声明一个变量。当变量以这种形式
+在全局或者一个函数内被声明时，它代表一个存储型变量。当他在类或者结构体中被声明时，他代表一个存储型变量属性。
+
+构造器表达式可以被
+
+和常量声明相比，如果变量名是一个元祖类型，元祖的每一项的名字都要和初始化表达式一致。
+
+正如名字一样，存储型变量的值或存储型变量属性存储在内存中。
+
+###计算型变量和计算型属性
+
+如下形式声明一个一个存储型变量或存储型属性：
+
+    var variable name: type {
+    get {
+        statements
+    }
+    set(setter name) {
+        statements
+    }
+    }
+
+你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
+当变量以这种形式在全局或者一个函数内被声明时，它代表一个计算型变量。当他在类，结构体，枚举，扩展声明的上下文
+中中被声明时，他代表一个计算型变量属性。
+
+getter用来读取变量值，setter用来写入变量值。setter子句是可选择的，只有getter是必需的，你可以将这些语句
+都省略，只是简单的直接返回请求值，正如在只读计算属性(read-only computed properites)中描述的那样。
+但是如果你提供了一个setter语句，你也必需提供一个getter语句。
+
+setter的名字和圆括号内的语句是可选的。如果你写了一个setter名，它就会作为setter的参数被使用。如果你不写setter名，
+setter的初始名为newValue，正如在seter声明速记(shorthand setter declaration)中提到的那样。
+
+不像存储型变量和存储型属性那样，计算型属性和计算型变量的值不存储在内存中。
+
+获得更多信息，查看更多关于计算型属性的例子，请查看计算型属性(computed properties)一节。
+
+###存储型变量监视器和属性监视器
+
+你可以用willset和didset监视器来声明一个存储型变量或属性。一个包含监视器的存储型变量或属性按如下的形式声明：
+
+    var variable name: type = expression {
+    willSet(setter name) {
+        statements
+    }
+    didSet(setter name {
+        statements
+    }
+    }
+
+你可以在全局，函数体内或者类，结构体，枚举，扩展声明的上下文中使用这种形式的声明。
+当变量以这种形式在全局或者一个函数内被声明时，监视器代表一个存储型变量监视器；
+当他在类，结构体，枚举，扩展声明的上下文中被声明时，监视器代表属性监视器。
+
+你可以为适合的监视器添加任何存储型属性。你也可以通过重写子类属性的方式为适合的监视器添加任何继承的属性
+(无论是存储型还是计算型的)，参见重写属性监视器(overriding properyt observers)。
+
+初始化表达式在类或者结构体的声明中是可选的，但是在其他地方是必需的。无论在什么地方声明，
+所有包含监视器的变量声明都必须有类型注释(type annotation)。
+
+当变量或属性的值被改变时，willset和didset监视器提供了一个监视方法（适当的回应）。
+监视器不会在变量或属性第一次初始化时不会被运行，他们只有在值被外部初始化语句改变时才会被运行。
+
+willset监视器只有在变量或属性值被改变之前运行。新的值作为一个常量经过过willset监视器，因此不可以在
+willset语句中改变它。didset监视器在变量或属性值被改变后立即运行。和willset监视器相反，为了以防止你仍然
+需要获得旧的数据，旧变量值或者属性会经过didset监视器。这意味着，如果你在变量或属性自身的didiset监视器语句
+中设置了一个值，你设置的新值会取代刚刚在willset监视器中经过的那个值。
+
+在willset和didset语句中，setter名和圆括号的语句是可选的。如果你写了一个setter名，它就会作为willset和didset的参数被使用。如果你不写setter名，
+willset监视器初始名为newvalue，didset监视器初始名为oldvalue。
+
+当你提供一个willset语句时，didset语句是可选的。同样的，在你提供了一个didset语句时，willset语句是可选的。
+
+获得更多信息，查看如何使用属性监视器的例子，请查看属性监视器(prpperty observers)一节。
+
+###类和静态变量属性
+
+class关键字用来声明类的计算型属性。static关键字用来声明类的静态变量属性。类和静态变量在类型属性(type properties)中有详细讨论。
+
+>GRAMMAR OF A VARIABLE DECLARATION
+
+>variable-declaration → variable-declaration-head­pattern-initializer-list­
+
+>variable-declaration → variable-declaration-head ­variable-name ­type-annotation ­code-block­
+
+>variable-declaration → variable-declaration-head ­variable-name ­type-annotation ­getter-setter-block­
+
+>variable-declaration → variable-declaration-head ­variable-name­ type-annotation ­getter-setter-keyword-block­
+
+ > variable-declaration → variable-declaration-head­ variable-name ­type-annotation­initializer­ opt ­willSet-didSet-block­
+
+>variable-declaration-head → attributes ­opt­ declaration-specifiers ­opt ­var
+­
+>variable-name → identifier­
+
+>getter-setter-block → {­getter-clause ­setter-clause­ opt­}­
+
+>getter-setter-block → {­setter-clause ­getter-clause­}­
+
+>getter-clause → attributes ­opt­get­code-block­
+
+>setter-clause → attributes ­opt ­set­ setter-name­ opt­ code-block­
+
+>setter-name → (­identifier­)­
+
+>getter-setter-keyword-block → {­getter-keyword-clause ­setter-keyword-clause­ opt­}
+­
+>getter-setter-keyword-block → {­setter-keyword-clause ­getter-keyword-clause­}
+
+>getter-keyword-clause → attributes­ opt­ get­
+
+>setter-keyword-clause → attributes ­opt­ set­
+
+>willSet-didSet-block → {­willSet-clause ­didSet-clause ­opt­}­
+
+>willSet-didSet-block → {­didSet-clause ­willSet-clause­}­
+
+>willSet-clause → attributes ­opt ­willSet ­setter-name­ opt ­code-block­
+
+>didSet-clause → attributes ­opt ­didSet ­setter-name ­opt­ code-block­
+
+
+##类型的别名声明
+
+类型别名的声明可以在你的程序里为一个已存在的类型声明一个别名。类型的别名声明以关键字typealias开始，遵循如下的
+形式：
+
+    typealias name = existing type
+
+当一个类型被别名被声明后，你可以在你程序的任何地方使用别名来代替已存在的类型。已存在的类型可以是已经被命名的
+类型或者是混合类型。类型的别名不产生新的类型，它只是简单的和已存在的类型做名称替换。
+
+查看更多Protocol Associated Type Declaration.
+
+>GRAMMAR OF A TYPE ALIAS DECLARATION
+
+> typealias-declaration → typealias-head­ typealias-assignment
+> typealias-head → typealias­ typealias-name
+> typealias-name → identifier
+> typealias-assignment → =type
+
+
+##函数声明
+
+你可以使用函数声明在你的程序里引入新的函数。函数可以在类的上下文，结构体，枚举，或者作为方法的协议中被声明。
+函数声明使用关键字func，遵循如下的形式：
+
+    func function name(parameters) -> return type {
+        statements
+    }
+
+如果函数不返回任何值，返回类型可以被忽略，如下所示：
+
+    func function name(parameters) {
+        statements
+    }
+
+每个参数的类型都要标明，它们不能被推断出来。初始时函数的参数是常值。在这些参数前面添加var使它们成为变量，
+作用域内任何对变量的改变只在函数体内有效，或者用inout使的这些改变可以在调用域内生效。
+更多关于in-out参数的讨论，参见in-out参数(in-out parameters)
+
+函数可以使用元组类型作为返回值来返回多个变量。
+
+函数定义可以出现在另一个函数声明内。这种函数被称作nested函数。更多关于nested函数的讨论，参见nestde functions。
+
+###参数名
+
+函数的参数是一个以逗号分隔的列表 。函数调用是的变量顺序必须和函数声明时的参数顺序一致。
+最简单的参数列表有着如下的形式：
+
+    parameter name: parameter type
+
+对于函数参数来讲，参数名在函数体内被使用，而不是在函数调用时使用。对于方法参数，参数名在函数体内被使用，
+同时也在方法被调用时作为标签被使用。该方法的第一个参数名仅仅在函数体内被使用，就像函数的参数一样，举例来讲：
+
+    func f(x: Int, y: String) -> String {
+        return y + String(x)
+    }
+    f(7, "hello")  // x and y have no name
+
+    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
+    #parameter name: parameter type
+    _ local parameter name: parameter type
+
+在本地参数前命名的第二名称(second name)使得参数有一个扩展名。且不同于本地的参数名。
+扩展参数名在函数被调用时必须被使用。对应的参数在方法或函数被调用时必须有扩展名 。
+
+在参数名前所写的哈希符号(#)代表着这个参数名可以同时作为外部或本体参数名来使用。等同于书写两次本地参数名。
+在函数或方法调用时，与其对应的语句必须包含这个名字。
+
+本地参数名前的强调字符(_)使参数在函数被调用时没有名称。在函数或方法调用时，与其对应的语句必须没有名字。
+
+###特殊类型的参数
+
+参数可以被忽略，值可以是变化的，并且提供一个初始值，这种方法有着如下的形式：
+
+    _ : <#parameter type#.
+    parameter name: parameter type...
+    parameter name: parameter type = default argument value
+
+以强调符(_)命名的参数明确的在函数体内不能被访问。
+
+一个以基础类型名的参数，如果紧跟着三个点(...)，被理解为是可变参数。一个函数至多可以拥有一个可变参数，
+且必须是最后一个参数。可变参数被作为该基本类型名的数组来看待。举例来讲，可变参数int...被看做是int[]。
+查看可变参数的使用例子，详见可变参数(variadic parameters)一节。
+
+在参数的类型后面有一个以等号(=)连接的表达式，这样的参数被看做有着给定表达式的初试值。如果参数在函数
+调用时被省略了，就会使用初始值。如果参数没有胜率，那么它在函数调用是必须有自己的名字.举例来讲，
+f()和f(x:7)都是只有一个变量x的函数的有效调用，但是f(7)是非法的，因为它提供了一个值而不是名称。
+
+###特殊方法
+
+以self修饰的枚举或结构体方法必须以mutating关键字作为函数声明头。
+
+子类重写的方法必须以override关键字作为函数声明头。不用override关键字重写的方法，使用了override关键字
+却并没有重写父类方法都会报错。
+
+和类型相关而不是和类型实例相关的方法必须在static声明的结构以或枚举内，亦或是以class关键字定义的类内。
+
+###柯里化函数和方法
+
+柯里化函数或方法有着如下的形式：
+
+    func function name(parameters)(parameters) -> return type {
+        statements
+    }
+
+以这种形式定义的函数的返回值是另一个函数。举例来说，下面的两个声明时等价的:
+
+    func addTwoNumbers(a: Int)(b: Int) -> Int {
+        return a + b
+    }
+    func addTwoNumbers(a: Int) -> (Int -> Int) {
+        func addTheSecondNumber(b: Int) -> Int {
+            return a + b
+        }
+        return addTheSecondNumber
+    }
+
+    addTwoNumbers(4)(5) // Returns 9
+
+多级柯里化应用如下
+
+>GRAMMAR OF A FUNCTION DECLARATION
+
+>function-declaration → function-head­ function-name­ generic-parameter-clause ­opt­function-signature­ function-body­
+> function-head → attributes ­opt ­declaration-specifiers ­opt ­func­
+> function-name → identifier­  operator­
+>function-signature → parameter-clauses ­function-result ­opt­
+> function-result → ->­attributes ­opt ­type­
+>  function-body → code-block­
+>  parameter-clauses → parameter-clause ­parameter-clauses ­opt­
+>  parameter-clause → (­)­  (­parameter-list­...­opt­)­
+>  parameter-list → parameter­  parameter­,­parameter-list­
+> parameter → inout ­opt ­let ­opt­#­opt­parameter-name local-parameter-name ­opt­ type-annotation ­default-argument-clause ­opt­
+> parameter → inout­opt­var­#­opt­parameter-name­local-parameter-name ­opt­ type-annotation­default-argument-clause ­opt­
+> parameter → attributes ­opt ­type­
+> parameter-name → identifier­  _­
+>  local-parameter-name → identifier­  _­
+>  default-argument-clause → =­expression­：
+
+
+##枚举声明
+
+在你的程序里使用枚举声明来引入一个枚举类型。
+
+枚举声明有两种基本的形式，使用关键字enum来声明。枚举声明体使用从零开始的变量——叫做枚举事件，和任意数量的
+声明，包括计算型属性，实例方法，静态方法，构造器，类型别名，甚至其他枚举，结构体，和类。枚举声明不能
+包含析构器或者协议声明。
+
+不像类或者结构体。枚举类型并不提供隐式的初始构造器，所有构造器必须显式的声明。构造器可以委托枚举中的其他
+构造器，但是构造过程仅当构造器将一个枚举时间完成后才全部完成。
+
+和结构体类似但是和类不同，枚举是值类型：枚举实例在赋予变量或常量时，或者被函数调用时被复制。
+更多关于值类型的信息，参见结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
+
+你可以扩展枚举类型，正如在扩展名声明(Extension Declaration)中讨论的一样。
+
+###任意事件类型的枚举
+
+如下的形式声明了一个包含任意类型枚举时间的枚举变量
+
+    enum enumeration name {
+        case enumeration case 1
+        case enumeration case 2(associated value types)
+    }
+
+这种形式的枚举声明在其他语言中有时被叫做可识别联合(discrinminated)。
+
+这种形式中，每一个事件块由关键字case开始，后面紧接着一个或多个以逗号分隔的枚举事件。每一个事件名必须是
+独一无二的。每一个事件也可以指定它所存储的指定类型的值，这些类型在关联值类型的元祖里被指定，立即书写在事件
+名后。获得更多关于关联值类型的信息和例子，请查看关联值(associated values)一节。
+
+###使用原始事件值的枚举
+
+以下的形式声明了一个包含相同基础类型的枚举事件的枚举：
+
+    enum enumeration name: raw value type {
+        case enumeration case 1 = raw value 1
+        case enumeration case 2 = raw value 2
+    }
+
+在这种形式中，每一个事件块由case关键字开始，后面紧接着一个或多个以逗号分隔的枚举事件。和第一种形式的枚举
+事件不同，这种形式的枚举事件包含一个同类型的基础值，叫做原始值(raw value)。这些值的类型在原始值类型(raw value type)
+中被指定，必须是字面上的整数，浮点数，字符或者字符串。
+
+每一个事件必须有唯一的名字，必须有一个唯一的初始值。如果初始值类型被指定为int，则不必为事件显式的指定值，
+它们会隐式的被标为值0,1,2等。每一个没有被赋值的Int类型时间会隐式的赋予一个初始值，它们是自动递增的。
+
+    num ExampleEnum: Int {
+        case A, B, C = 5, D
+    }
+
+在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是。因为ExampleEnum.C的值被显式的设定为5，因此
+ExampleEnum.D的值会自动增长为6.
+
+枚举事件的初始值可以调用方法roRaw获得，如ExampleEnum.B.toRaw()。你也可以通过调用fromRaw方法来使用初始值找到
+其对应的事件，并返回一个可选的事件。查看更多信息和获取初始值类型事件的信息，参阅初始值(raw values)。
+
+###获得枚举事件
+
+使用点(.)来引用枚举类型的事件，如 EnumerationType.EnumerationCase。当枚举类型可以上下文推断出时，你可以
+省略它(.仍然需要)，参照枚举语法(Enumeration Syntax)和显式成员表达(Implicit Member Expression).
+
+使用switch语句来检验枚举事件的值，正如使用switch语句匹配枚举值（Matching Enumeration Values with a Switch Statement)一节描述的那样。
+
+枚举类型是模式匹配(pattern-matched)的，和其相反的是switch语句case块中枚举事件匹配，在枚举事件类型(Enumeration Case Pattern)中有描述。
+
+>GRAMMAR OF AN ENUMERATION DECLARATION
+
+>   enum-declaration → attributes­opt­union-style-enum­  attributes­opt­raw-value-style-enum­
+>    union-style-enum → enum-name­generic-parameter-clause­opt­{­union-style-enum-members­opt­}­
+    union-style-enum-members → union-style-enum-member­union-style-enum-members­opt­
+    union-style-enum-member → declaration­  union-style-enum-case-clause­
+    union-style-enum-case-clause → attributes­opt­case­union-style-enum-case-list­
+    union-style-enum-case-list → union-style-enum-case­  union-style-enum-case­,­union-style-enum-case-list­
+    union-style-enum-case → enum-case-name­tuple-type­opt­
+    enum-name → identifier­
+    enum-case-name → identifier­
+    raw-value-style-enum → enum-name­generic-parameter-clause­opt­:­type-identifier­{­raw-value-style-enum-members­opt­}­
+    raw-value-style-enum-members → raw-value-style-enum-member­raw-value-style-enum-members­opt­
+    raw-value-style-enum-member → declaration­  raw-value-style-enum-case-clause­
+    raw-value-style-enum-case-clause → attributes­opt­case­raw-value-style-enum-case-list­
+    raw-value-style-enum-case-list → raw-value-style-enum-case­  raw-value-style-enum-case­,­raw-value-style-enum-case-list­
+    raw-value-style-enum-case → enum-case-name­raw-value-assignment­opt­
+    raw-value-assignment → =­literal­
+
+
+##结构体声明
+
+使用结构体声明可以在你的程序里引入一个结构体类型。结构体声明使用struct关键字，遵循如下的形式：
+
+    struct structure name: adopted protocols {
+        declarations
+    }
+
+结构体内包含零或多个声明。这些声明可以包括存储型和计算型属性，静态属性，实例方法，静态方法，构造器，
+类型别名，甚至其他结构体，类，和枚举声明。结构体声明不能包含析构器或者协议声明。详细讨论和包含多种结构体
+声明的实例，参见类和结构体一节。
+
+结构体可以包含任意数量的协议，但是不能继承自类，枚举或者其他结构体。
+
+有三种方法可以创建一个声明过的结构体实例：
+
+-调用结构体内声明的构造器，参照构造器(initializers)一节。
+
+—如果没有声明构造器，调用结构体的逐个构造器，详情参见Memberwise Initializers for Structure Types.
+
+—如果没有声明析构器，结构体的所有属性都有初始值，调用结构体的默认构造器，详情参见默认构造器(Default Initializers).
+
+结构体的构造过程参见初始化(initiaization)一节。
+
+结构体实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
+
+结构体是值类型；结构体的实例在被赋予变量或常量，被函数调用时被复制。获得关于值类型更多信息，参见
+结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
+
+你可以使用扩展声明来扩展结构体类型的行为，参见扩展声明(Extension Declaration).
+
+>GRAMMAR OF A STRUCTURE DECLARATION
+
+>    struct-declaration → attributes­opt­struct­struct-name­generic-parameter-clause­opt­type-inheritance-clause­opt­struct-body­
+>    struct-name → identifier­
+>    struct-body → {­declarations­opt­}
+
+
+##类声明
+
+你可以在你的程序中使用类声明来引入一个类。类声明使用关键字class，遵循如下的形式：
+
+    class class name: superclass, adopted protocols {
+        declarations
+    }
+
+一个类内包含零或多个声明。这些声明可以包括存储型和计算型属性，实例方法，类方法，构造器，单独的析构器方法，
+类型别名，甚至其他结构体，类，和枚举声明。类声明不能包含协议声明。详细讨论和包含多种类声明的实例，参见类和
+结构体一节。
+
+一个类只能继承一个父类，超类，但是可以包含任意数量的协议。这些超类第一次在type-inheritance-clause出现，遵循任意协议。
+
+正如在初始化声明(Initializer Declaration)谈及的那样，类可以有指定和方便的构造器。当你声明任一中构造器时，
+你可以使用requierd变量来标记构造器，要求任意子类来重写它。指定类的构造器必须初始化类所有的已声明的属性，
+它必须在子类构造器调用前被执行。
+
+类可以重写属性，方法和它的超类的构造器。重写的方法和属性必须以override标注。
+
+虽然超类的属性和方法声明可以被当前类继承，但是超类声明的指定构造器却不能。这意味着，如果当前类重写了超类
+的所有指定构造器，它就继承了超类的方便构造器。Swift的类并不是继承自一个全局基础类。
+
+有两种方法来创建已声明的类的实例：
+
+-调用类的一个构造器，参见构造器(initializers)。
+
+-如果没有声明构造器，而且类的所有属性都被赋予了初始值，调用类的默认构造器，参见默认构造器(default initializers).
+
+类实例属性可以用点(.)来获得，详情参见获得属性(Accessing Properties)一节。
+
+类是引用类型；当被赋予常量或变量，函数调用时，类的实例是被引用，而不是复制。获得更多关于引用类型的信息，
+结构体和枚举都是值类型(Structures and Enumerations Are Value Types)一节。
+
+你可以使用扩展声明来扩展类的行为，参见扩展声明(Extension Declaration).
+
+ >  GRAMMAR OF A CLASS DECLARATION
+
+ >   class-declaration → attributes­opt­class­class-name­generic-parameter-clause­opt­type-inheritance-clause­opt­class-body­
+ >   class-name → identifier­
+ >  class-body → {­declarations­opt­}
+
+
+##协议声明(translated by 小一)
+
+一个协议声明为你的程序引入一个命名了的协议类型。协议声明使用 `protocol` 关键词来进行声明并有下面这样的形式：
+
+```javascript
+protocol protocol name: inherited protocols {
+	protocol member declarations
+}
+```
+
+协议的主体包含零或多个协议成员声明，这些成员描述了任何采用该协议必须满足的一致性要求。特别的，一个协议可以声明必须实现某些属性、方法、初始化程序及附属脚本的一致性类型。协议也可以声明专用种类的类型别名，叫做关联类型，它可以指定协议的不同声明之间的关系。协议成员声明会在下面的详情里进行讨论。
+
+协议类型可以从很多其它协议那继承。当一个协议类型从其它协议那继承的时候，来自其它协议的所有要求就集合了，而且从当前协议继承的任何类型必须符合所有的这些要求。对于如何使用协议继承的例子，查看[协议继承](../chapter2/21_Protocols.html#protocol_inheritance)
+
+> 注意：
+>
+你也可以使用协议合成类型集合多个协议的一致性要求，详情参见[协议合成类型](../chapter3/03_Types.html#protocol_composition_type)和[协议合成](../chapter2/21_Protocols.html#protocol_composition)
+
+你可以通过采用在类型的扩展声明中的协议来为之前声明的类型添加协议一致性。在扩展中你必须实现所有采用协议的要求。如果该类型已经实现了所有的要求，你可以让这个扩展声明的主题留空。
+
+默认地，符合某一个协议的类型必须实现所有声明在协议中的属性、方法和附属脚本。也就是说，你可以用`optional`属性标注这些协议成员声明以指定它们的一致性类型实现是可选的。`optional`属性仅仅可以用于使用`objc`属性标记过的协议。这样的结果就是仅仅类类型可以采用并符合包含可选成员要求的协议。更多关于如何使用`optional`属性的信息及如何访问可选协议成员的指导——比如当你不能肯定是否一致性的类型实现了它们——参见[可选协议要求](../chapter2/21_Protocols.html#optional_protocol_requirements)
+
+为了限制协议的采用仅仅针对类类型，需要使用`class_protocol`属性标记整个协议声明。任意继承自标记有`class_protocol`属性协议的协议都可以智能地仅能被类类型采用。
+
+>注意：
+>
+如果协议已经用`object`属性标记了，`class_protocol`属性就隐性地应用于该协议；没有必要再明确地使用`class_protocol`属性来标记该协议了。
+
+协议是命名的类型，因此它们可以以另一个命名类型出现在你代码的所有地方，就像[协议类型](../chapter2/21_Protocols.html#protocols_as_types)里讨论的那样。然而你不能构造一个协议的实例，因为协议实际上不提供它们指定的要求的实现。
+
+你可以使用协议来声明一个类的代理的方法或者应该实现的结构，就像[委托(代理)模式](../chapter2/21_Protocols.html#delegation)描述的那样。
+
+>协议声明的语法
+protocol-declaration → attributes­opt­protocol­protocol-name­type-inheritance-clause­opt­protocol-body­
+protocol-name → identifier­
+protocol-body → {­protocol-member-declarations­opt­}­
+protocol-member-declaration → protocol-property-declaration­
+protocol-member-declaration → protocol-method-declaration­
+protocol-member-declaration → protocol-initializer-declaration­
+protocol-member-declaration → protocol-subscript-declaration­
+protocol-member-declaration → protocol-associated-type-declaration­
+protocol-member-declarations → protocol-member-declaration­protocol-member-declarations­opt­
+
+
+###协议属性声明
+
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议属性声明来实现一个属性。协议属性声明有一种特殊的类型声明形式：
+
+```javascript
+var property name: type { get set }
+```
+
+同其它协议成员声明一样，这些属性声明仅仅针对符合该协议的类型声明了`getter`和`setter`要求。结果就是你不需要在协议里它被声明的地方实现`getter`和`setter`。
+
+`getter`和`setter`要求可以通过一致性类型以各种方式满足。如果属性声明包含`get`和`set`关键词，一致性类型就可以用可读写（实现了`getter`和`setter`）的存储型变量属性或计算型属性，但是属性不能以常量属性或只读计算型属性实现。如果属性声明仅仅包含`get`关键词的话，它可以作为任意类型的属性被实现。比如说实现了协议的属性要求的一致性类型，参见[属性要求](../chapter2/21_Protocols.html#property_requirements)
+
+更多参见[变量声明](../chapter3/05_Declarations.html#variable_declaration)
+
+>协议属性声明语法
+protocol-property-declaration → variable-declaration-head­variable-name­type-annotation­getter-setter-keyword-block­
+
+###协议方法声明
+
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议方法声明来实现一个方法.
+协议方法声明和函数方法声明有着相同的形式，包含如下两条规则：他们不包括函数体，你不能在类的声明内为他们的
+参数提供初始值.举例来说，符合的类型执行协议必需的方法。参见必需方法一节。
+
+使用关键字class可以在协议声明中声明一个类或必需的静态方法。执行这些方法的类也用关键字class声明。
+相反的，执行这些方法的结构体必须以关键字static声明。如果你想使用扩展方法，在扩展类时使用class关键字，
+在扩展结构体时使用static关键字。
+
+更多请参阅函数声明。
+
+>GRAMMAR OF A PROTOCOL METHOD DECLARATION
+
+>protocol-method-declaration → function-head­function-name­generic-parameter-clause­opt­function-signature­
+
+###协议构造器声明
+
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议构造器声明来实现一个构造器。协议构造器声明
+除了不包含构造器体外，和构造器声明有着相同的形式，
+
+更多请参阅构造器声明。
+
+>GRAMMAR OF A PROTOCOL INITIALIZER DECLARATION
+
+>protocol-initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­
+
+###协议附属脚本声明
+
+协议声明了一致性类型必须在协议声明的主体里通过引入一个协议附属脚本声明来实现一个附属脚本。协议属性声明
+对附属脚本声明有一个特殊的形式：
+
+>subscript (parameters) -> return type { get set }
+
+附属脚本声明只为和协议一致的类型声明了必需的最小数量的的getter和setter。如果附属脚本申明包含get和set关键字，
+一致的类型也必须有一个getter和setter语句。如果附属脚本声明值包含get关键字，一致的类型必须至少包含一个
+getter语句，可以选择是否包含setter语句。
+
+更多参阅附属脚本声明。
+
+>GRAMMAR OF A PROTOCOL SUBSCRIPT DECLARATION
+
+>protocol-subscript-declaration → subscript-head­subscript-result­getter-setter-keyword-block­
+
+###协议相关类型声明
+
+协议声明相关类型使用关键字typealias。相关类型为作为协议声明的一部分的类型提供了一个别名。相关类型和参数
+语句中的类型参数很相似，但是它们在声明的协议中包含self关键字。在这些语句中，self指代和协议一致的可能的类型。
+获得更多信息和例子，查看相关类型或类型别名声明。
+
+>GRAMMAR OF A PROTOCOL ASSOCIATED TYPE DECLARATION
+
+>protocol-associated-type-declaration → typealias-head­type-inheritance-clause­opt­typealias-assignment­opt­
+
+
+##构造器声明
+
+构造器声明会为程序内的类，结构体或枚举引入构造器。构造器使用关键字Init来声明，遵循两条基本形式。
+
+结构体，枚举，类可以有任意数量的构造器，但是类的构造器的规则和行为是不一样的。不像结构体和枚举那样，类
+有两种结构体，designed initializers 和convenience initializers，参见构造器一节。
+
+如下的形式声明了结构体，枚举和类的指定构造器：
+
+    init(parameters) {
+         statements
+    }
+
+类的指定构造器将类的所有属性直接初始化。如果类有超类，它不能调用该类的其他构造器,它只能调用超类的一个
+指定构造器。如果该类从它的超类处继承了任何属性，这些属性在当前类内被赋值或修饰时，必须带哦用一个超类的
+指定构造器。
+
+指定构造器可以在类声明的上下文中声明，因此它不能用扩展声明的方法加入一个类中。
+
+结构体和枚举的构造器可以带哦用其他的已声明的构造器，来委托其中一个火全部进行初始化过程。
+
+以关键字convenience来声明一个类的便利构造器：
+
+    convenience init(parameters) {
+       statements
+    }
+
+便利构造器可以将初始化过程委托给另一个便利构造器或类的一个指定构造器。这意味着，类的初始化过程必须
+以一个将所有类属性完全初始化的指定构造器的调用作为结束。便利构造器不能调用超类的构造器。
+
+你可以使用requierd关键字，将便利构造器和指定构造器标记为每个子类的构造器都必须拥有的。因为指定构造器
+不被子类继承，他们必须被立即执行。当子类直接执行所有超类的指定构造器(或使用便利构造器重写指定构造器)时，
+必需的便利构造器可以被隐式的执行，亦可以被继承。不像方法，附属脚本那样，你不需要为这些重写的构造器标注
+overrride关键字。
+
+查看更多关于不同声明方法的构造器的例子，参阅构造过程一节。
+
+>GRAMMAR OF AN INITIALIZER DECLARATION
+
+>initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­initializer-body­
+>initializer-head → attributes­opt­convenience­opt­init­
+>initializer-body → code-block­
+
+
+##析构声明
+
+析构声明为类声明了一个析构器。析构器没有参数，遵循如下的格式：
+
+    deinit {
+       statements
+    }
+
+当类没有任何语句时将要被释放时，析构器会自动的被调用。析构器在类的声明体内只能被声明一次——但是不能在
+类的扩展声明内，每个类最多只能有一个。
+
+子类继承了它的超类的析构器，在子类将要被释放时隐式的调用。子类在所有析构器被执行完毕前不会被释放。
+
+析构器不会被直接调用。
+
+查看例子和如何在类的声明中使用析构器，参见析构过程一节
+。
+
+>GRAMMAR OF A DEINITIALIZER DECLARATION
+
+>deinitializer-declaration → attributes­opt­deinit­code-block
+
+
+##扩展声明
+
+扩展声明用于扩展一个现存的类，结构体，枚举的行为。扩展声明以关键字extension开始，遵循如下的规则：
+
+    extension type: adopted protocols {
+       declarations
+    }
+
+一个扩展声明体包括零个或多个声明。这些声明可以包括计算型属性，计算型静态属性，实例方法，静态和类方法，构造器，
+附属脚本声明，甚至其他结构体，类，和枚举声明。扩展声明不能包含析构器，协议声明，存储型属性，属性监测器或其他
+的扩展属性。详细讨论和查看包含多种扩展声明的实例，参见扩展一节。
+
+扩展声明可以向现存的类，结构体，枚举内添加一致的协议。扩展声明不能向一个类中添加继承的类，因此
+type-inheritance-clause是一个只包含协议列表的扩展声明。
+
+属性，方法，现存类型的构造器不能被它们类型的扩展所重写。
+
+扩展声明可以包含构造器声明，这意味着，如果你扩展的类型在其他模块中定义，构造器声明必须委托另一个在
+那个模块里声明的构造器来恰当的初始化。
+
+>GRAMMAR OF AN EXTENSION DECLARATION
+
+>extension-declaration → extension­type-identifier­type-inheritance-clause­opt­extension-body­
+>extension-body → {­declarations­opt­}­
+
+
+##附属脚本声明(translated by 林)
+
+附属脚本用于向特定类型添加附属脚本支持，通常为访问集合，列表和序列的元素时提供语法便利。附属脚本声明使用关键字`subscript`，声明形式如下：
+> subscript (`parameter`) -> (return type){
+    get{
+      `statements`
+    }
+    set(`setter name`){
+      `statements`
+    }
+}
+附属脚本声明只能在类，结构体，枚举，扩展和协议声明的上下文进行声明。
+
+_变量(parameters)_指定一个或多个用于在相关类型的附属脚本中访问元素的索引（例如，表达式`object[i]`中的`i`）。尽管用于元素访问的索引可以是任意类型的，但是每个变量必须包含一个用于指定每种索引类型的类型标注。_返回类型(return type)_指定被访问的元素的类型。
+
+和计算性属性一样，附属脚本声明支持对访问元素的读写操作。getter用于读取值，setter用于写入值。setter子句是可选的，当仅需要一个getter子句时，可以将二者都忽略且直接返回请求的值即可。也就是说，如果使用了setter子句，就必须使用getter子句。
+
+setter的名字和封闭的括号是可选的。如果使用了setter名称，它会被当做传给setter的变量的名称。如果不使用setter名称，那么传给setter的变量的名称默认是`value`。setter名称的类型必须与_返回类型(return type)_的类型相同。
+
+可以在附属脚本声明的类型中，可以重载附属脚本，只要_变量(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)。
+
+>GRAMMAR OF A SUBSCRIPT DECLARATION
+
+>subscript-declaration → subscript-head­subscript-result­code-block­
+>subscript-declaration → subscript-head­subscript-result­getter-setter-block­
+>subscript-declaration → subscript-head­subscript-result­getter-setter-keyword-block­
+>subscript-head → attributes­opt­subscript­parameter-clause­
+>subscript-result → ->­attributes­opt­type­
+
+
+##运算符声明(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 infix `operator name`{
+    precedence `precedence level`
+    associativity `associativity`
+ }
+
+_中缀_运算符是二元运算符，它可以被置于两个操作数之间，比如表达式`1 + 2` 中的加法运算符(`+`)。
+
+中缀运算符可以可选地指定优先级，结合性，或两者同时指定。
+
+运算符的_优先级_可以指定在没有括号包围的情况下，运算符与它的操作数如何紧密绑定的。可以使用上下文关键字`precedence`并_优先级(precedence level)_一起来指定一个运算符的优先级。_优先级_可以是0到255之间的任何一个数字(十进制整数)；与十进制整数字面量不同的是，它不可以包含任何下划线字符。尽管优先级是一个特定的数字，但它仅用作与另一个运算符比较(大小)。也就是说，一个操作数可以同时被两个运算符使用时，例如`2 + 3 * 5`，优先级更高的运算符将优先与操作数绑定。
+
+运算符的_结合性_可以指定在没有括号包围的情况下，优先级相同的运算符以何种顺序被分组的。可以使用上下文关键字`associativity`并_结合性(associativity)_一起来指定一个运算符的结合性，其中_结合性_可以说是上下文关键字`left`，`right`或`none`中的任何一个。左结合运算符以从左到右的形式分组。例如，减法运算符(`-`)具有左结合性，因此`4 - 5 - 6`被以`(4 - 5) - 6`的形式分组，其结果为`-7`。
+右结合运算符以从右到左的形式分组，对于设置为`none`的非结合运算符，它们不以任何形式分组。具有相同优先级的非结合运算符，不可以互相邻接。例如，表达式`1 < 2 < 3`非法的。
+
+声明时不指定任何优先级或结合性的中缀运算符，它们的优先级会被初始化为100，结合性被初始化为`none`。
+
+下面的这种形式声明了一个新的前缀运算符：
+> operator prefix `operator name`{}
+
+紧跟在操作数前边的_前缀运算符(prefix operator)_是一元运算符，例如表达式`++i`中的前缀递增运算符(`++`)。
+
+前缀运算符的声明中不指定优先级。前缀运算符是非结合的。
+
+下面的这种形式声明了一个新的后缀运算符：
+
+> operator postfix `operator name`{}
+
+紧跟在操作数后边的_后缀运算符(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)。
+
+>GRAMMAR OF AN OPERATOR DECLARATION
+>
+>operator-declaration → prefix-operator-declaration­  postfix-operator-declaration­  >infix-operator-declaration­
+>prefix-operator-declaration → operator ­prefix­ operator­{­}­
+>postfix-operator-declaration → operator ­postfix­ operator­{­}­
+>infix-operator-declaration → operator­infix­operator­{­infix-operator-attributes­opt­}­
+>infix-operator-attributes → precedence-clause­opt­associativity-clause­opt­
+>precedence-clause → precedence­precedence-level­
+>precedence-level → Digit 0 through 255
+>associativity-clause → associativity­associativity­
+>associativity → left­  right­  none
diff --git a/source/chapter3/06_Attributes.md b/source/chapter3/06_Attributes.md
index 248c0276..bf661f30 100644
--- a/source/chapter3/06_Attributes.md
+++ b/source/chapter3/06_Attributes.md
@@ -1,6 +1,15 @@
+> 翻译：Hawstein
+
+> 校对：numbbbbb
+
 # 特性
 -----------------
 
+本页内容包括：
+
+- [声明特性](#declaration_attributes)
+- [类型特性](#type_attributes)
+
 特性提供了关于声明和类型的更多信息。在Swift中有两类特性，用于修饰声明的以及用于修饰类型的。例如，`required`特性，当应用于一个类的指定或便利初始化器声明时，表明它的每个子类都必须实现那个初始化器。再比如`noreturn`特性，当应用于函数或方法类型时，表明该函数或方法不会返回到它的调用者。
 
 通过以下方式指定一个特性：符号`@`后面跟特性名，如果包含参数，则把参数带上：
@@ -12,6 +21,7 @@
 
 有些声明特性通过接收参数来指定特性的更多信息以及它是如何修饰一个特定的声明的。这些特性的参数写在小括号内，它们的格式由它们所属的特性来定义。
 
+
 ## 声明特性
 
 声明特性只能应用于声明。然而，你也可以将`noreturn`特性应用于函数或方法类型。
@@ -91,6 +101,7 @@ Interface Builder特性是Interface Builder用来与Xcode同步的声明特性
 
 `IBOutlet`和`IBInspectable`用于修饰一个类的属性声明；`IBAction`特性用于修饰一个类的方法声明；`IBDesignable`用于修饰类的声明。
 
+
 ## 类型特性
 
 类型特性只能用于修饰类型。然而，你也可以用`noreturn`特性去修饰函数或方法声明。
diff --git a/source/chapter3/07_Patterns.md b/source/chapter3/07_Patterns.md
index 9efceedd..ae6263ac 100644
--- a/source/chapter3/07_Patterns.md
+++ b/source/chapter3/07_Patterns.md
@@ -1,6 +1,20 @@
+> 翻译：honghaoz
+
+> 校对：numbbbbb
+
 # 模式（Patterns）
 -----------------
 
+本页内容包括：
+
+- [通配符模式（Wildcard Pattern）](#wildcard_pattern)
+- [标识符模式（Identifier Pattern）](#identifier_pattern)
+- [值绑定模式（Value-Binding Pattern）](#value-binding_pattern)
+- [元组模式（Tuple Pattern）](#tuple_pattern)
+- [枚举案例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
+- [类型转换模式（Type-Casting Patterns）](#type-casting_patterns)
+- [表达式模式（Expression Pattern）](#expression_pattern)
+
 模式（pattern）代表了单个值或者复合值的结构。例如，元组`(1, 2)`的结构是逗号分隔的，包含两个元素的列表。因为模式代表一种值的结构，而不是特定的某个值，你可以把模式和各种同类型的值匹配起来。比如，`(x, y)`可以匹配元组`(1, 2)`，以及任何含两个元素的元组。除了将模式与一个值匹配外，你可以从合成值中提取出部分或全部，然后分别把各个部分和一个常量或变量绑定起来。
 
 在Swift中，模式出现在变量和常量的声明（在它们的左侧），`for-in`语句和`switch`语句（在他们的case标签）中。尽管任何模式都可以出现在`switch`语句的case标签中，但在其他情况下，只有通配符模式（wildcard pattern），标识符模式（identifier pattern）和包含这两种模式的模式才能出现。
@@ -8,21 +22,22 @@
 你可以为通配符模式（wildcard pattern），标识符模式（identifier pattern）和元组模式（tuple pattern）指定类型注释，用来限制这种模式只匹配某种类型的值。
 
 > 模式的语法：
-> 
+>
 > pattern → wildcard-patterntype-annotationopt
-> 
+>
 > pattern → identifier-patterntype-annotationopt
-> 
+>
 > pattern → value-binding-pattern
-> 
+>
 > pattern → tuple-patterntype-annotationopt
-> 
+>
 > pattern → enum-case-pattern
-> 
+>
 > pattern → type-casting-pattern
-> 
+>
 > pattern → expression-pattern
 
+
 ## 通配符模式（Wildcard Pattern）
 
 通配符模式匹配并忽略任何值，包含一个下划线（_）。当你不关心被匹配的值时，可以使用此模式。例如，下面这段代码进行了`1...3`的循环，并忽略了每次循环的值：
@@ -32,23 +47,25 @@
 			}
 
 > 通配符模式的语法：
-> 
+>
 > wildcard-pattern → _
 
+
 ## 标识符模式（Identifier Pattern）
 
 标识符模式匹配任何值，并将匹配的值和一个变量或常量绑定起来。例如，在下面的常量申明中，`someValue`是一个标识符模式，匹配了类型是`Int`的`42`。
 
 			let someValue = 42
-			
+
 当匹配成功时，`42`被绑定（赋值）给常量`someValue`。
 
 当一个变量或常量申明的左边是标识符模式时，此时，标识符模式是隐式的值绑定模式（value-binding pattern）。
 
 > 标识符模式的语法：
-> 
+>
 > identifier-pattern → identifier
 
+
 ## 值绑定模式（Value-Binding Pattern）
 
 值绑定模式绑定匹配的值到一个变量或常量。当绑定匹配值给常量时，用关键字`let`,绑定给变量时，用关键之`var`。
@@ -62,13 +79,14 @@
     			println("The point is at (\(x), \(y)).")
 			}
 			// prints "The point is at (3, 2).”
-			
+
 在上面这个例子中，`let`将元组模式`(x, y)`分配到各个标识符模式。因为这种行为，`switch`语句中`case let (x, y):`和`case (let x, let y):`匹配的值是一样的。
 
 > 值绑定模式的语法：
-> 
+>
 > value-binding-pattern → var pattern | let pattern
 
+
 ## 元组模式（Tuple Pattern）
 
 元组模式是逗号分隔的列表，包含一个或多个模式，并包含在一对圆括号中。元组模式匹配相应元组类型的值。
@@ -88,15 +106,16 @@
 			let a = 2        // a: Int = 2
 			let (a) = 2      // a: Int = 2
 			let (a): Int = 2 // a: Int = 2
-			
+
 > 元组模式的语法：
-> 
+>
 > tuple-pattern → (tuple-pattern-element-list opt)
-> 
+>
 > tuple-pattern-element-list → tuple-pattern-element | tuple-pattern-element, tuple-pattern-element-list
-> 
+>
 > tuple-pattern-element → pattern
 
+
 ## 枚举案例模式（Enumeration Case Pattern）
 
 枚举案例模式匹配现有的枚举类型的某种案例。枚举案例模式仅在`switch`语句中的`case`标签中出现。
@@ -104,16 +123,17 @@
 如果你准备匹配的枚举案例有任何关联的值，则相应的枚举案例模式必须指定一个包含每个关联值元素的元组模式。关于使用`switch`语句来匹配包含关联值枚举案例的例子，请参阅`Associated Values`.
 
 > 枚举案例模式的语法：
-> 
+>
 > enum-case-pattern → type-identifier opt . enum-case-name tuple-pattern opt
 
+
 ## 类型转换模式（Type-Casting Patterns）
 
 有两种类型转换模式，`is`模式和`as`模式。这两种模式均只出现在`switch`语句中的`case`标签中。`is`模式和`as`模式有以下形式：
 
 			is type
 			pattern as type
-			
+
 `is`模式匹配一个值，如果这个值的类型在运行时（runtime）和`is`模式右边的指定类型（或者那个类型的子类）是一致的。`is`模式和`is`操作符一样，他们都进行类型转换，但是抛弃了返回的类型。
 
 `as`模式匹配一个值，如果这个值的类型在运行时（runtime）和`as`模式右边的指定类型（或者那个类型的子类）是一致的。一旦匹配成功，匹配的值的类型被转换成`as`模式左边指定的模式。
@@ -121,13 +141,14 @@
 关于使用`switch`语句来匹配`is`模式和`as`模式值的例子，请参阅`Type Casting for Any and AnyObject`。
 
 > 类型转换模式的语法：
-> 
+>
 > type-casting-pattern → is-pattern  as-pattern
-> 
+>
 > is-pattern → istype
-> 
+>
 > as-pattern → patternastype
 
+
 ## 表达式模式（Expression Pattern）
 
 表达式模式代表了一个表达式的值。这个模式只出现在`switch`语句中的`case`标签中。
@@ -162,6 +183,6 @@
 			// prints "(1, 2) is near the origin.”
 
 > 表达式模式的语法：
-> 
+>
 > expression-pattern → expression
 
diff --git a/source/chapter3/08_Generic_Parameters_and_Arguments.md b/source/chapter3/08_Generic_Parameters_and_Arguments.md
index 11629de8..2779e782 100644
--- a/source/chapter3/08_Generic_Parameters_and_Arguments.md
+++ b/source/chapter3/08_Generic_Parameters_and_Arguments.md
@@ -1,3 +1,7 @@
+> 翻译：fd5788
+
+> 校对：yankuangshi
+
 # 泛型参数
 ---------
 
diff --git a/source/chapter3/09_Summary_of_the_Grammar.md b/source/chapter3/09_Summary_of_the_Grammar.md
index 339b6f2c..dd4777f4 100644
--- a/source/chapter3/09_Summary_of_the_Grammar.md
+++ b/source/chapter3/09_Summary_of_the_Grammar.md
@@ -1,740 +1,744 @@
+> 翻译：StanZhai
+
+> 校对：xielingwang
+
 # 语法总结
 -----------------
 
 本页包含内容：
 
-* [语句（Statements）](#label1)
-* [泛型参数（Generic Parameters and Arguments）](#label2)
-* [声明（Declarations）](#label3)
-* [模式（Patterns）](#label4)
-* [特性（Attributes）](#label5)
-* [表达式（Expressions）](#label6)
-* [词法结构（Lexical Structure）](#label7)
-* [类型（Types）](#label8)
+* [语句（Statements）](#statements)
+* [泛型参数（Generic Parameters and Arguments）](#generic_parameters_and_arguments)
+* [声明（Declarations）](#declarations)
+* [模式（Patterns）](#patterns)
+* [特性（Attributes）](#attributes)
+* [表达式（Expressions）](#expressions)
+* [词法结构（Lexical Structure）](#lexical_structure)
+* [类型（Types）](#types)
 
-
+
 ## 语句
 
-> 语句语法  
-> *statement* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **;** _opt_  
-> *statement* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) **;** _opt_  
-> *statement* → [*loop-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/loop-statement) **;** _opt_  
-> *statement* → [*branch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/branch-statement) **;** _opt_  
-> *statement* → [*labeled-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/labeled-statement)  
-> *statement* → [*control-transfer-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/control-transfer-statement) **;** _opt_  
-> *statements* → [*statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_  
+> 语句语法
+> *statement* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **;** _opt_
+> *statement* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) **;** _opt_
+> *statement* → [*loop-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/loop-statement) **;** _opt_
+> *statement* → [*branch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/branch-statement) **;** _opt_
+> *statement* → [*labeled-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/labeled-statement)
+> *statement* → [*control-transfer-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/control-transfer-statement) **;** _opt_
+> *statements* → [*statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_
 
 
          
 
-> 循环语句语法  
-> *loop-statement* → [*for-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-statement)  
-> *loop-statement* → [*for-in-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-in-statement)  
-> *loop-statement* → [*while-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/wheetatype类型ile-statement)  
-> *loop-statement* → [*do-while-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/do-while-statement)  
+> 循环语句语法
+> *loop-statement* → [*for-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-statement)
+> *loop-statement* → [*for-in-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-in-statement)
+> *loop-statement* → [*while-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/wheetatype类型ile-statement)
+> *loop-statement* → [*do-while-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/do-while-statement)
 
 
          
 
-> For 循环语法  
-> *for-statement* → **for** [*for-init*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-init) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *for-statement* → **for** **(** [*for-init*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-init) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **)** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *for-init* → [*variable-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration) | [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list)  
+> For 循环语法
+> *for-statement* → **for** [*for-init*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-init) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *for-statement* → **for** **(** [*for-init*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/for-init) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **;** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_ **)** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *for-init* → [*variable-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration) | [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list)
 
 
          
 
-> For-In 循环语法  
-> *for-in-statement* → **for** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) **in** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
+> For-In 循环语法
+> *for-in-statement* → **for** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) **in** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
 
 
          
 
-> While 循环语法  
-> *while-statement* → **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *while-condition* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration)  
+> While 循环语法
+> *while-statement* → **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *while-condition* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration)
 
 
          
 
-> Do-While 循环语法  
-> *do-while-statement* → **do** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition)  
+> Do-While 循环语法
+> *do-while-statement* → **do** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition)
 
 
          
 
-> 分支语句语法  
-> *branch-statement* → [*if-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-statement)  
-> *branch-statement* → [*switch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-statement)  
+> 分支语句语法
+> *branch-statement* → [*if-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-statement)
+> *branch-statement* → [*switch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-statement)
 
 
          
 
-> If 语句语法  
-> *if-statement* → **if** [*if-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-condition) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) [*else-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/else-clause) _opt_  
-> *if-condition* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration)  
-> *else-clause* → **else** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) | **else** [*if-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-statement)  
+> If 语句语法
+> *if-statement* → **if** [*if-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-condition) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) [*else-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/else-clause) _opt_
+> *if-condition* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration)
+> *else-clause* → **else** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) | **else** [*if-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/if-statement)
 
 
          
 
-> Switch 语句语法  
-> *switch-statement* → **switch** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **{** [*switch-cases*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-cases) _opt_ **}**  
-> *switch-cases* → [*switch-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-case) [*switch-cases*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-cases) _opt_  
-> *switch-case* → [*case-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-label) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) | [*default-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/default-label) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements)  
-> *switch-case* → [*case-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-label) **;** | [*default-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/default-label) **;**  
-> *case-label* → **case** [*case-item-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-item-list) **:**  
-> *case-item-list* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*guard-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-clause) _opt_ | [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*guard-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-clause) _opt_ **,** [*case-item-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-item-list)  
-> *default-label* → **default** **:**  
-> *guard-clause* → **where** [*guard-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-expression)  
-> *guard-expression* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> Switch 语句语法
+> *switch-statement* → **switch** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **{** [*switch-cases*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-cases) _opt_ **}**
+> *switch-cases* → [*switch-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-case) [*switch-cases*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-cases) _opt_
+> *switch-case* → [*case-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-label) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) | [*default-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/default-label) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements)
+> *switch-case* → [*case-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-label) **;** | [*default-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/default-label) **;**
+> *case-label* → **case** [*case-item-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-item-list) **:**
+> *case-item-list* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*guard-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-clause) _opt_ | [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*guard-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-clause) _opt_ **,** [*case-item-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/case-item-list)
+> *default-label* → **default** **:**
+> *guard-clause* → **where** [*guard-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/guard-expression)
+> *guard-expression* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
 
          
 
-> 带标签的语句语法  
-> *labeled-statement* → [*statement-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement-label) [*loop-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/loop-statement) | [*statement-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement-label) [*switch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-statement)  
-> *statement-label* → [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) **:**  
-> *label-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 带标签的语句语法
+> *labeled-statement* → [*statement-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement-label) [*loop-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/loop-statement) | [*statement-label*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement-label) [*switch-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/switch-statement)
+> *statement-label* → [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) **:**
+> *label-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 控制传递语句语法  
-> *control-transfer-statement* → [*break-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/break-statement)  
-> *control-transfer-statement* → [*continue-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/continue-statement)  
-> *control-transfer-statement* → [*fallthrough-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/fallthrough-statement)  
-> *control-transfer-statement* → [*return-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/return-statement)  
+> 控制传递语句语法
+> *control-transfer-statement* → [*break-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/break-statement)
+> *control-transfer-statement* → [*continue-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/continue-statement)
+> *control-transfer-statement* → [*fallthrough-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/fallthrough-statement)
+> *control-transfer-statement* → [*return-statement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/return-statement)
 
 
          
 
-> Break 语句语法  
-> *break-statement* → **break** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) _opt_  
+> Break 语句语法
+> *break-statement* → **break** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) _opt_
 
 
          
 
-> Continue 语句语法  
-> *continue-statement* → **continue** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) _opt_  
+> Continue 语句语法
+> *continue-statement* → **continue** [*label-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/label-name) _opt_
 
 
          
 
-> Fallthrough 语句语法  
-> *fallthrough-statement* → **fallthrough**  
+> Fallthrough 语句语法
+> *fallthrough-statement* → **fallthrough**
 
 
          
 
-> Return 语句语法  
-> *return-statement* → **return** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_  
+> Return 语句语法
+> *return-statement* → **return** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) _opt_
 
-
+
 ## 泛型参数
 
-> 泛型形参子句语法  
-> *generic-parameter-clause* → **<** [*generic-parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-list) [*requirement-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-clause) _opt_ **>**  
-> *generic-parameter-list* → [*generic-parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter) | [*generic-parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter) **,** [*generic-parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-list)  
-> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name)  
-> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)  
-> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) **:** [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type)  
-> *requirement-clause* → **where** [*requirement-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-list)  
-> *requirement-list* → [*requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement) | [*requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement) **,** [*requirement-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-list)  
-> *requirement* → [*conformance-requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/conformance-requirement) | [*same-type-requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/same-type-requirement)  
-> *conformance-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)  
-> *conformance-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **:** [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type)  
-> *same-type-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **==** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)  
+> 泛型形参子句语法
+> *generic-parameter-clause* → **<** [*generic-parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-list) [*requirement-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-clause) _opt_ **>**
+> *generic-parameter-list* → [*generic-parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter) | [*generic-parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter) **,** [*generic-parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-list)
+> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name)
+> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)
+> *generic-parameter* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) **:** [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type)
+> *requirement-clause* → **where** [*requirement-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-list)
+> *requirement-list* → [*requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement) | [*requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement) **,** [*requirement-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/requirement-list)
+> *requirement* → [*conformance-requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/conformance-requirement) | [*same-type-requirement*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/same-type-requirement)
+> *conformance-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)
+> *conformance-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **:** [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type)
+> *same-type-requirement* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **==** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)
 
 
          
 
-> 泛型实参子句语法  
-> *generic-argument-clause* → **<** [*generic-argument-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-list) **>**  
-> *generic-argument-list* → [*generic-argument*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument) | [*generic-argument*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument) **,** [*generic-argument-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-list)  
-> *generic-argument* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 泛型实参子句语法
+> *generic-argument-clause* → **<** [*generic-argument-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-list) **>**
+> *generic-argument-list* → [*generic-argument*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument) | [*generic-argument*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument) **,** [*generic-argument-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-list)
+> *generic-argument* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
-
+
 ## 声明 (Declarations)
 
-> 声明语法  
-> *declaration* → [*import-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-declaration)  
-> *declaration* → [*constant-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/constant-declaration)  
-> *declaration* → [*variable-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration)  
-> *declaration* → [*typealias-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-declaration)  
-> *declaration* → [*function-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-declaration)  
-> *declaration* → [*enum-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-declaration)  
-> *declaration* → [*struct-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-declaration)  
-> *declaration* → [*class-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-declaration)  
-> *declaration* → [*protocol-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-declaration)  
-> *declaration* → [*initializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-declaration)  
-> *declaration* → [*deinitializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/deinitializer-declaration)  
-> *declaration* → [*extension-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/extension-declaration)  
-> *declaration* → [*subscript-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-declaration)  
-> *declaration* → [*operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/operator-declaration)  
-> *declarations* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_  
-> *declaration-specifiers* → [*declaration-specifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifier) [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_  
-> *declaration-specifier* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**  
+> 声明语法
+> *declaration* → [*import-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-declaration)
+> *declaration* → [*constant-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/constant-declaration)
+> *declaration* → [*variable-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration)
+> *declaration* → [*typealias-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-declaration)
+> *declaration* → [*function-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-declaration)
+> *declaration* → [*enum-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-declaration)
+> *declaration* → [*struct-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-declaration)
+> *declaration* → [*class-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-declaration)
+> *declaration* → [*protocol-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-declaration)
+> *declaration* → [*initializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-declaration)
+> *declaration* → [*deinitializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/deinitializer-declaration)
+> *declaration* → [*extension-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/extension-declaration)
+> *declaration* → [*subscript-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-declaration)
+> *declaration* → [*operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/operator-declaration)
+> *declarations* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_
+> *declaration-specifiers* → [*declaration-specifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifier) [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_
+> *declaration-specifier* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**
 
 
          
 
-> 顶级声明语法  
-> *top-level-declaration* → [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_  
+> 顶级声明语法
+> *top-level-declaration* → [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_
 
 
          
 
-> 代码块语法  
-> *code-block* → **{** [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_ **}**  
+> 代码块语法
+> *code-block* → **{** [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) _opt_ **}**
 
 
          
 
-> Import 声明语法  
-> *import-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **import** [*import-kind*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-kind) _opt_ [*import-path*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path)  
-> *import-kind* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**  
-> *import-path* → [*import-path-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path-identifier) | [*import-path-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path-identifier) **.** [*import-path*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path)  
-> *import-path-identifier* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)  
+> Import 声明语法
+> *import-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **import** [*import-kind*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-kind) _opt_ [*import-path*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path)
+> *import-kind* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**
+> *import-path* → [*import-path-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path-identifier) | [*import-path-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path-identifier) **.** [*import-path*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/import-path)
+> *import-path-identifier* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
 
 
          
 
-> 常数声明语法  
-> *constant-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **let** [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)  
-> *pattern-initializer-list* → [*pattern-initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer) | [*pattern-initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer) **,** [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)  
-> *pattern-initializer* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer) _opt_  
-> *initializer* → **=** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> 常数声明语法
+> *constant-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **let** [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)
+> *pattern-initializer-list* → [*pattern-initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer) | [*pattern-initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer) **,** [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)
+> *pattern-initializer* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) [*initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer) _opt_
+> *initializer* → **=** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
 
          
 
-> 变量声明语法  
-> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)  
-> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-block)  
-> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)  
-> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer) _opt_ [*willSet-didSet-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-didSet-block)  
-> *variable-declaration-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **var**  
-> *variable-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *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) **}**  
-> *getter-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **get** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *setter-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **set** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *setter-name* → **(** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **)**  
-> *getter-setter-keyword-block* → **{** [*getter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-keyword-clause) [*setter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-keyword-clause) _opt_ **}**  
-> *getter-setter-keyword-block* → **{** [*setter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-keyword-clause) [*getter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-keyword-clause) **}**  
-> *getter-keyword-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **get**  
-> *setter-keyword-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **set**  
-> *willSet-didSet-block* → **{** [*willSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-clause) [*didSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/didSet-clause) _opt_ **}**  
-> *willSet-didSet-block* → **{** [*didSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/didSet-clause) [*willSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-clause) **}**  
-> *willSet-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **willSet** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *didSet-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **didSet** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
+> 变量声明语法
+> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*pattern-initializer-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/pattern-initializer-list)
+> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-block)
+> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)
+> *variable-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*initializer*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer) _opt_ [*willSet-didSet-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-didSet-block)
+> *variable-declaration-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **var**
+> *variable-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *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) **}**
+> *getter-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **get** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *setter-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **set** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *setter-name* → **(** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **)**
+> *getter-setter-keyword-block* → **{** [*getter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-keyword-clause) [*setter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-keyword-clause) _opt_ **}**
+> *getter-setter-keyword-block* → **{** [*setter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-keyword-clause) [*getter-keyword-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-keyword-clause) **}**
+> *getter-keyword-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **get**
+> *setter-keyword-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **set**
+> *willSet-didSet-block* → **{** [*willSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-clause) [*didSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/didSet-clause) _opt_ **}**
+> *willSet-didSet-block* → **{** [*didSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/didSet-clause) [*willSet-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/willSet-clause) **}**
+> *willSet-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **willSet** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *didSet-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **didSet** [*setter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-name) _opt_ [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
 
 
          
 
-> 类型别名声明语法  
-> *typealias-declaration* → [*typealias-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-head) [*typealias-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-assignment)  
-> *typealias-head* → **typealias** [*typealias-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-name)  
-> *typealias-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *typealias-assignment* → **=** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 类型别名声明语法
+> *typealias-declaration* → [*typealias-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-head) [*typealias-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-assignment)
+> *typealias-head* → **typealias** [*typealias-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-name)
+> *typealias-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *typealias-assignment* → **=** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 函数声明语法  
-> *function-declaration* → [*function-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-head) [*function-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*function-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-signature) [*function-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-body)  
-> *function-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **func**  
-> *function-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)  
-> *function-signature* → [*parameter-clauses*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clauses) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_  
-> *function-result* → **->** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
-> *function-body* → [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *parameter-clauses* → [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*parameter-clauses*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clauses) _opt_  
-> *parameter-clause* → **(** **)** | **(** [*parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-list) **...** _opt_ **)**  
-> *parameter-list* → [*parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter) | [*parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter) **,** [*parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-list)  
-> *parameter* → **inout** _opt_ **let** _opt_ **#** _opt_ [*parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-name) [*local-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/local-parameter-name) _opt_ [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*default-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/default-argument-clause) _opt_  
-> *parameter* → **inout** _opt_ **var** **#** _opt_ [*parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-name) [*local-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/local-parameter-name) _opt_ [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*default-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/default-argument-clause) _opt_  
-> *parameter* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
-> *parameter-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | **_**  
-> *local-parameter-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | **_**  
-> *default-argument-clause* → **=** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> 函数声明语法
+> *function-declaration* → [*function-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-head) [*function-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*function-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-signature) [*function-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-body)
+> *function-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*declaration-specifiers*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration-specifiers) _opt_ **func**
+> *function-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
+> *function-signature* → [*parameter-clauses*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clauses) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_
+> *function-result* → **->** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
+> *function-body* → [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *parameter-clauses* → [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*parameter-clauses*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clauses) _opt_
+> *parameter-clause* → **(** **)** | **(** [*parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-list) **...** _opt_ **)**
+> *parameter-list* → [*parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter) | [*parameter*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter) **,** [*parameter-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-list)
+> *parameter* → **inout** _opt_ **let** _opt_ **#** _opt_ [*parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-name) [*local-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/local-parameter-name) _opt_ [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*default-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/default-argument-clause) _opt_
+> *parameter* → **inout** _opt_ **var** **#** _opt_ [*parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-name) [*local-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/local-parameter-name) _opt_ [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*default-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/default-argument-clause) _opt_
+> *parameter* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
+> *parameter-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | **_**
+> *local-parameter-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | **_**
+> *default-argument-clause* → **=** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
 
          
 
-> 枚举声明语法  
-> *enum-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*union-style-enum*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum) | [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*raw-value-style-enum*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum)  
-> *union-style-enum* → [*enum-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ **{** [*union-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-members) _opt_ **}**  
-> *union-style-enum-members* → [*union-style-enum-member*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-member) [*union-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-members) _opt_  
-> *union-style-enum-member* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) | [*union-style-enum-case-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-clause)  
-> *union-style-enum-case-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **case** [*union-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-list)  
-> *union-style-enum-case-list* → [*union-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case) | [*union-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case) **,** [*union-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-list)  
-> *union-style-enum-case* → [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*tuple-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type) _opt_  
-> *enum-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *enum-case-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *raw-value-style-enum* → [*enum-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **{** [*raw-value-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-members) _opt_ **}**  
-> *raw-value-style-enum-members* → [*raw-value-style-enum-member*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-member) [*raw-value-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-members) _opt_  
-> *raw-value-style-enum-member* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) | [*raw-value-style-enum-case-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-clause)  
-> *raw-value-style-enum-case-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **case** [*raw-value-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-list)  
-> *raw-value-style-enum-case-list* → [*raw-value-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case) | [*raw-value-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case) **,** [*raw-value-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-list)  
-> *raw-value-style-enum-case* → [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*raw-value-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-assignment) _opt_  
-> *raw-value-assignment* → **=** [*literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/literal)  
+> 枚举声明语法
+> *enum-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*union-style-enum*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum) | [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*raw-value-style-enum*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum)
+> *union-style-enum* → [*enum-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ **{** [*union-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-members) _opt_ **}**
+> *union-style-enum-members* → [*union-style-enum-member*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-member) [*union-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-members) _opt_
+> *union-style-enum-member* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) | [*union-style-enum-case-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-clause)
+> *union-style-enum-case-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **case** [*union-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-list)
+> *union-style-enum-case-list* → [*union-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case) | [*union-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case) **,** [*union-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/union-style-enum-case-list)
+> *union-style-enum-case* → [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*tuple-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type) _opt_
+> *enum-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *enum-case-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *raw-value-style-enum* → [*enum-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ **:** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **{** [*raw-value-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-members) _opt_ **}**
+> *raw-value-style-enum-members* → [*raw-value-style-enum-member*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-member) [*raw-value-style-enum-members*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-members) _opt_
+> *raw-value-style-enum-member* → [*declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declaration) | [*raw-value-style-enum-case-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-clause)
+> *raw-value-style-enum-case-clause* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **case** [*raw-value-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-list)
+> *raw-value-style-enum-case-list* → [*raw-value-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case) | [*raw-value-style-enum-case*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case) **,** [*raw-value-style-enum-case-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-style-enum-case-list)
+> *raw-value-style-enum-case* → [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*raw-value-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/raw-value-assignment) _opt_
+> *raw-value-assignment* → **=** [*literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/literal)
 
 
          
 
-> 结构体声明语法  
-> *struct-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **struct** [*struct-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*struct-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-body)  
-> *struct-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *struct-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**  
+> 结构体声明语法
+> *struct-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **struct** [*struct-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*struct-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/struct-body)
+> *struct-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *struct-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**
 
 
          
 
-> 类声明语法  
-> *class-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **class** [*class-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*class-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-body)  
-> *class-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *class-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**  
+> 类声明语法
+> *class-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **class** [*class-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*class-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/class-body)
+> *class-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *class-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**
 
 
          
 
-> 协议声明语法  
-> *protocol-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **protocol** [*protocol-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-name) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*protocol-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-body)  
-> *protocol-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *protocol-body* → **{** [*protocol-member-declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declarations) _opt_ **}**  
-> *protocol-member-declaration* → [*protocol-property-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-property-declaration)  
-> *protocol-member-declaration* → [*protocol-method-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-method-declaration)  
-> *protocol-member-declaration* → [*protocol-initializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-initializer-declaration)  
-> *protocol-member-declaration* → [*protocol-subscript-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-subscript-declaration)  
-> *protocol-member-declaration* → [*protocol-associated-type-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-associated-type-declaration)  
-> *protocol-member-declarations* → [*protocol-member-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declaration) [*protocol-member-declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declarations) _opt_  
+> 协议声明语法
+> *protocol-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **protocol** [*protocol-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-name) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*protocol-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-body)
+> *protocol-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *protocol-body* → **{** [*protocol-member-declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declarations) _opt_ **}**
+> *protocol-member-declaration* → [*protocol-property-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-property-declaration)
+> *protocol-member-declaration* → [*protocol-method-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-method-declaration)
+> *protocol-member-declaration* → [*protocol-initializer-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-initializer-declaration)
+> *protocol-member-declaration* → [*protocol-subscript-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-subscript-declaration)
+> *protocol-member-declaration* → [*protocol-associated-type-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-associated-type-declaration)
+> *protocol-member-declarations* → [*protocol-member-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declaration) [*protocol-member-declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/protocol-member-declarations) _opt_
 
 
          
 
-> 协议属性声明语法  
-> *protocol-property-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)  
+> 协议属性声明语法
+> *protocol-property-declaration* → [*variable-declaration-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-declaration-head) [*variable-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/variable-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)
 
 
          
 
-> 协议方法声明语法  
-> *protocol-method-declaration* → [*function-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-head) [*function-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*function-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-signature)  
+> 协议方法声明语法
+> *protocol-method-declaration* → [*function-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-head) [*function-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-name) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*function-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-signature)
 
 
          
 
-> 协议构造函数声明语法  
-> *protocol-initializer-declaration* → [*initializer-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-head) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause)  
+> 协议构造函数声明语法
+> *protocol-initializer-declaration* → [*initializer-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-head) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause)
 
 
          
 
-> 协议附属脚本声明语法  
-> *protocol-subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)  
+> 协议附属脚本声明语法
+> *protocol-subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)
 
 
          
 
-> 协议关联类型声明语法  
-> *protocol-associated-type-declaration* → [*typealias-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-head) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*typealias-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-assignment) _opt_  
+> 协议关联类型声明语法
+> *protocol-associated-type-declaration* → [*typealias-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-head) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*typealias-assignment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/typealias-assignment) _opt_
 
 
          
 
-> 构造函数声明语法  
-> *initializer-declaration* → [*initializer-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-head) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*initializer-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-body)  
-> *initializer-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **convenience** _opt_ **init**  
-> *initializer-body* → [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
+> 构造函数声明语法
+> *initializer-declaration* → [*initializer-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-head) [*generic-parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-parameter-clause) _opt_ [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*initializer-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/initializer-body)
+> *initializer-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **convenience** _opt_ **init**
+> *initializer-body* → [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
 
 
          
 
-> 析构函数声明语法  
-> *deinitializer-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **deinit** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
+> 析构函数声明语法
+> *deinitializer-declaration* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **deinit** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
 
 
          
 
-> 扩展声明语法  
-> *extension-declaration* → **extension** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*extension-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/extension-body)  
-> *extension-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**  
+> 扩展声明语法
+> *extension-declaration* → **extension** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) [*type-inheritance-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-clause) _opt_ [*extension-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/extension-body)
+> *extension-body* → **{** [*declarations*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/declarations) _opt_ **}**
 
 
          
 
-> 附属脚本声明语法  
-> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)  
-> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-block)  
-> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)  
-> *subscript-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **subscript** [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause)  
-> *subscript-result* → **->** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 附属脚本声明语法
+> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block)
+> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-block)
+> *subscript-declaration* → [*subscript-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-head) [*subscript-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/subscript-result) [*getter-setter-keyword-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-setter-keyword-block)
+> *subscript-head* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **subscript** [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause)
+> *subscript-result* → **->** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 运算符声明语法  
-> *operator-declaration* → [*prefix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/prefix-operator-declaration) | [*postfix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/postfix-operator-declaration) | [*infix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/infix-operator-declaration)  
-> *prefix-operator-declaration* → **operator** **prefix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** **}**  
-> *postfix-operator-declaration* → **operator** **postfix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** **}**  
-> *infix-operator-declaration* → **operator** **infix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** [*infix-operator-attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/infix-operator-attributes) _opt_ **}**  
-> *infix-operator-attributes* → [*precedence-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/precedence-clause) _opt_ [*associativity-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/associativity-clause) _opt_  
-> *precedence-clause* → **precedence** [*precedence-level*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/precedence-level)  
-> *precedence-level* → Digit 0 through 255  
-> *associativity-clause* → **associativity** [*associativity*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/associativity)  
-> *associativity* → **left** | **right** | **none**  
+> 运算符声明语法
+> *operator-declaration* → [*prefix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/prefix-operator-declaration) | [*postfix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/postfix-operator-declaration) | [*infix-operator-declaration*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/infix-operator-declaration)
+> *prefix-operator-declaration* → **operator** **prefix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** **}**
+> *postfix-operator-declaration* → **operator** **postfix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** **}**
+> *infix-operator-declaration* → **operator** **infix** [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) **{** [*infix-operator-attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/infix-operator-attributes) _opt_ **}**
+> *infix-operator-attributes* → [*precedence-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/precedence-clause) _opt_ [*associativity-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/associativity-clause) _opt_
+> *precedence-clause* → **precedence** [*precedence-level*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/precedence-level)
+> *precedence-level* → Digit 0 through 255
+> *associativity-clause* → **associativity** [*associativity*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/associativity)
+> *associativity* → **left** | **right** | **none**
 
-
+
 ## 模式
 
-> 模式语法  
-> *pattern* → [*wildcard-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/wildcard-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_  
-> *pattern* → [*identifier-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/identifier-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_  
-> *pattern* → [*value-binding-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/value-binding-pattern)  
-> *pattern* → [*tuple-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_  
-> *pattern* → [*enum-case-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/enum-case-pattern)  
-> *pattern* → [*type-casting-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/type-casting-pattern)  
-> *pattern* → [*expression-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/expression-pattern)  
+> 模式语法
+> *pattern* → [*wildcard-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/wildcard-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_
+> *pattern* → [*identifier-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/identifier-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_
+> *pattern* → [*value-binding-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/value-binding-pattern)
+> *pattern* → [*tuple-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation) _opt_
+> *pattern* → [*enum-case-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/enum-case-pattern)
+> *pattern* → [*type-casting-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/type-casting-pattern)
+> *pattern* → [*expression-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/expression-pattern)
 
 
          
 
-> 通配符模式语法  
-> *wildcard-pattern* → **_**  
+> 通配符模式语法
+> *wildcard-pattern* → **_**
 
 
          
 
-> 标识符模式语法  
-> *identifier-pattern* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 标识符模式语法
+> *identifier-pattern* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 值绑定模式语法  
-> *value-binding-pattern* → **var** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) | **let** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern)  
+> 值绑定模式语法
+> *value-binding-pattern* → **var** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) | **let** [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern)
 
 
          
 
-> 元组模式语法  
-> *tuple-pattern* → **(** [*tuple-pattern-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element-list) _opt_ **)**  
-> *tuple-pattern-element-list* → [*tuple-pattern-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element) | [*tuple-pattern-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element) **,** [*tuple-pattern-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element-list)  
-> *tuple-pattern-element* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern)  
+> 元组模式语法
+> *tuple-pattern* → **(** [*tuple-pattern-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element-list) _opt_ **)**
+> *tuple-pattern-element-list* → [*tuple-pattern-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element) | [*tuple-pattern-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element) **,** [*tuple-pattern-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern-element-list)
+> *tuple-pattern-element* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern)
 
 
          
 
-> 枚举用例模式语法  
-> *enum-case-pattern* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) _opt_ **.** [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*tuple-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern) _opt_  
+> 枚举用例模式语法
+> *enum-case-pattern* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) _opt_ **.** [*enum-case-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/enum-case-name) [*tuple-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/tuple-pattern) _opt_
 
 
          
 
-> 类型转换模式语法  
-> *type-casting-pattern* → [*is-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/is-pattern) | [*as-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/as-pattern)  
-> *is-pattern* → **is** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
-> *as-pattern* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) **as** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 类型转换模式语法
+> *type-casting-pattern* → [*is-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/is-pattern) | [*as-pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/as-pattern)
+> *is-pattern* → **is** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
+> *as-pattern* → [*pattern*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Patterns.html#//apple_ref/swift/grammar/pattern) **as** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 表达式模式语法  
-> *expression-pattern* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> 表达式模式语法
+> *expression-pattern* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
-
+
 ## 特性
 
-> 特性语法  
-> *attribute* → **@** [*attribute-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute-name) [*attribute-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute-argument-clause) _opt_  
-> *attribute-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *attribute-argument-clause* → **(** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **)**  
-> *attributes* → [*attribute*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute) [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_  
-> *balanced-tokens* → [*balanced-token*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-token) [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_  
-> *balanced-token* → **(** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **)**  
-> *balanced-token* → **[** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **]**  
-> *balanced-token* → **{** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **}**  
-> *balanced-token* → Any identifier, keyword, literal, or operator  
-> *balanced-token* → Any punctuation except (­, )­, [­, ]­, {­, or }­  
+> 特性语法
+> *attribute* → **@** [*attribute-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute-name) [*attribute-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute-argument-clause) _opt_
+> *attribute-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *attribute-argument-clause* → **(** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **)**
+> *attributes* → [*attribute*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attribute) [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_
+> *balanced-tokens* → [*balanced-token*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-token) [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_
+> *balanced-token* → **(** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **)**
+> *balanced-token* → **[** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **]**
+> *balanced-token* → **{** [*balanced-tokens*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/balanced-tokens) _opt_ **}**
+> *balanced-token* → Any identifier, keyword, literal, or operator
+> *balanced-token* → Any punctuation except (­, )­, [­, ]­, {­, or }­
 
-
+
 ## 表达式
 
-> 表达式语法  
-> *expression* → [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression) [*binary-expressions*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expressions) _opt_  
-> *expression-list* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **,** [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list)  
+> 表达式语法
+> *expression* → [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression) [*binary-expressions*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expressions) _opt_
+> *expression-list* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **,** [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list)
 
 
          
 
-> 前缀表达式语法  
-> *prefix-expression* → [*prefix-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/prefix-operator) _opt_ [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression)  
-> *prefix-expression* → [*in-out-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/in-out-expression)  
-> *in-out-expression* → **&** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 前缀表达式语法
+> *prefix-expression* → [*prefix-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/prefix-operator) _opt_ [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression)
+> *prefix-expression* → [*in-out-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/in-out-expression)
+> *in-out-expression* → **&** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 二进制表达式语法  
-> *binary-expression* → [*binary-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)  
-> *binary-expression* → [*assignment-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/assignment-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)  
-> *binary-expression* → [*conditional-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/conditional-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)  
-> *binary-expression* → [*type-casting-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/type-casting-operator)  
-> *binary-expressions* → [*binary-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expression) [*binary-expressions*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expressions) _opt_  
+> 二进制表达式语法
+> *binary-expression* → [*binary-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)
+> *binary-expression* → [*assignment-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/assignment-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)
+> *binary-expression* → [*conditional-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/conditional-operator) [*prefix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/prefix-expression)
+> *binary-expression* → [*type-casting-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/type-casting-operator)
+> *binary-expressions* → [*binary-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expression) [*binary-expressions*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/binary-expressions) _opt_
 
 
          
 
-> 赋值运算符语法  
-> *assignment-operator* → **=**  
+> 赋值运算符语法
+> *assignment-operator* → **=**
 
 
          
 
-> 条件运算符语法  
-> *conditional-operator* → **?** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **:**  
+> 条件运算符语法
+> *conditional-operator* → **?** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **:**
 
 
          
 
-> 类型转换运算符语法  
-> *type-casting-operator* → **is** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) | **as** **?** _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 类型转换运算符语法
+> *type-casting-operator* → **is** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) | **as** **?** _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 主表达式语法  
-> *primary-expression* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_  
-> *primary-expression* → [*literal-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/literal-expression)  
-> *primary-expression* → [*self-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/self-expression)  
-> *primary-expression* → [*superclass-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-expression)  
-> *primary-expression* → [*closure-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-expression)  
-> *primary-expression* → [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression)  
-> *primary-expression* → [*implicit-member-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/implicit-member-expression)  
-> *primary-expression* → [*wildcard-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/wildcard-expression)  
+> 主表达式语法
+> *primary-expression* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_
+> *primary-expression* → [*literal-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/literal-expression)
+> *primary-expression* → [*self-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/self-expression)
+> *primary-expression* → [*superclass-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-expression)
+> *primary-expression* → [*closure-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-expression)
+> *primary-expression* → [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression)
+> *primary-expression* → [*implicit-member-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/implicit-member-expression)
+> *primary-expression* → [*wildcard-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/wildcard-expression)
 
 
          
 
-> 字面量表达式语法  
-> *literal-expression* → [*literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/literal)  
-> *literal-expression* → [*array-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal) | [*dictionary-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal)  
-> *literal-expression* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__**  
-> *array-literal* → **[** [*array-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-items) _opt_ **]**  
-> *array-literal-items* → [*array-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-item) **,** _opt_ | [*array-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-item) **,** [*array-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-items)  
-> *array-literal-item* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
-> *dictionary-literal* → **[** [*dictionary-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-items) **]** | **[** **:** **]**  
-> *dictionary-literal-items* → [*dictionary-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-item) **,** _opt_ | [*dictionary-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-item) **,** [*dictionary-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-items)  
-> *dictionary-literal-item* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **:** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> 字面量表达式语法
+> *literal-expression* → [*literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/literal)
+> *literal-expression* → [*array-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal) | [*dictionary-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal)
+> *literal-expression* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__**
+> *array-literal* → **[** [*array-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-items) _opt_ **]**
+> *array-literal-items* → [*array-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-item) **,** _opt_ | [*array-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-item) **,** [*array-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/array-literal-items)
+> *array-literal-item* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
+> *dictionary-literal* → **[** [*dictionary-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-items) **]** | **[** **:** **]**
+> *dictionary-literal-items* → [*dictionary-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-item) **,** _opt_ | [*dictionary-literal-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-item) **,** [*dictionary-literal-items*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dictionary-literal-items)
+> *dictionary-literal-item* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **:** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
 
          
 
-> Self 表达式语法  
-> *self-expression* → **self**  
-> *self-expression* → **self** **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *self-expression* → **self** **[** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**  
-> *self-expression* → **self** **.** **init**  
+> Self 表达式语法
+> *self-expression* → **self**
+> *self-expression* → **self** **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *self-expression* → **self** **[** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**
+> *self-expression* → **self** **.** **init**
 
 
          
 
-> 超类表达式语法  
-> *superclass-expression* → [*superclass-method-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-method-expression) | [*superclass-subscript-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-subscript-expression) | [*superclass-initializer-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-initializer-expression)  
-> *superclass-method-expression* → **super** **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
-> *superclass-subscript-expression* → **super** **[** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**  
-> *superclass-initializer-expression* → **super** **.** **init**  
+> 超类表达式语法
+> *superclass-expression* → [*superclass-method-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-method-expression) | [*superclass-subscript-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-subscript-expression) | [*superclass-initializer-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/superclass-initializer-expression)
+> *superclass-method-expression* → **super** **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
+> *superclass-subscript-expression* → **super** **[** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**
+> *superclass-initializer-expression* → **super** **.** **init**
 
 
          
 
-> 闭包表达式语法  
-> *closure-expression* → **{** [*closure-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-signature) _opt_ [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) **}**  
-> *closure-signature* → [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**  
-> *closure-signature* → [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**  
-> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**  
-> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**  
-> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) **in**  
-> *capture-list* → **[** [*capture-specifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-specifier) [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**  
-> *capture-specifier* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**  
+> 闭包表达式语法
+> *closure-expression* → **{** [*closure-signature*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-signature) _opt_ [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements) **}**
+> *closure-signature* → [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**
+> *closure-signature* → [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**
+> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) [*parameter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/parameter-clause) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**
+> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list) [*function-result*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/function-result) _opt_ **in**
+> *closure-signature* → [*capture-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-list) **in**
+> *capture-list* → **[** [*capture-specifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/capture-specifier) [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **]**
+> *capture-specifier* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
 
 
          
 
-> 隐式成员表达式语法  
-> *implicit-member-expression* → **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 隐式成员表达式语法
+> *implicit-member-expression* → **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 带圆括号的表达式语法  
-> *parenthesized-expression* → **(** [*expression-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element-list) _opt_ **)**  
-> *expression-element-list* → [*expression-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element) | [*expression-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element) **,** [*expression-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element-list)  
-> *expression-element* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **:** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)  
+> 带圆括号的表达式语法
+> *parenthesized-expression* → **(** [*expression-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element-list) _opt_ **)**
+> *expression-element-list* → [*expression-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element) | [*expression-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element) **,** [*expression-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-element-list)
+> *expression-element* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) | [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **:** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
 
          
 
-> 通配符表达式语法  
-> *wildcard-expression* → **_**  
+> 通配符表达式语法
+> *wildcard-expression* → **_**
 
 
          
 
-> 后缀表达式语法  
-> *postfix-expression* → [*primary-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/primary-expression)  
-> *postfix-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*postfix-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/postfix-operator)  
-> *postfix-expression* → [*function-call-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/function-call-expression)  
-> *postfix-expression* → [*initializer-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/initializer-expression)  
-> *postfix-expression* → [*explicit-member-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/explicit-member-expression)  
-> *postfix-expression* → [*postfix-self-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-self-expression)  
-> *postfix-expression* → [*dynamic-type-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dynamic-type-expression)  
-> *postfix-expression* → [*subscript-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/subscript-expression)  
-> *postfix-expression* → [*forced-value-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/forced-value-expression)  
-> *postfix-expression* → [*optional-chaining-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/optional-chaining-expression)  
+> 后缀表达式语法
+> *postfix-expression* → [*primary-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/primary-expression)
+> *postfix-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*postfix-operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/postfix-operator)
+> *postfix-expression* → [*function-call-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/function-call-expression)
+> *postfix-expression* → [*initializer-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/initializer-expression)
+> *postfix-expression* → [*explicit-member-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/explicit-member-expression)
+> *postfix-expression* → [*postfix-self-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-self-expression)
+> *postfix-expression* → [*dynamic-type-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/dynamic-type-expression)
+> *postfix-expression* → [*subscript-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/subscript-expression)
+> *postfix-expression* → [*forced-value-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/forced-value-expression)
+> *postfix-expression* → [*optional-chaining-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/optional-chaining-expression)
 
 
          
 
-> 函数调用表达式语法  
-> *function-call-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression)  
-> *function-call-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression) _opt_ [*trailing-closure*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/trailing-closure)  
-> *trailing-closure* → [*closure-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-expression)  
+> 函数调用表达式语法
+> *function-call-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression)
+> *function-call-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) [*parenthesized-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/parenthesized-expression) _opt_ [*trailing-closure*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/trailing-closure)
+> *trailing-closure* → [*closure-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/closure-expression)
 
 
          
 
-> 初始化表达式语法  
-> *initializer-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **init**  
+> 初始化表达式语法
+> *initializer-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **init**
 
 
          
 
-> 显式成员表达式语法  
-> *explicit-member-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit)  
-> *explicit-member-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_  
+> 显式成员表达式语法
+> *explicit-member-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit)
+> *explicit-member-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_
 
 
          
 
-> Self 表达式语法  
-> *postfix-self-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **self**  
+> Self 表达式语法
+> *postfix-self-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **self**
 
 
          
 
-> 动态类型表达式语法  
-> *dynamic-type-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **dynamicType**  
+> 动态类型表达式语法
+> *dynamic-type-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **.** **dynamicType**
 
 
          
 
-> 附属脚本表达式语法  
-> *subscript-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **[** [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list) **]**  
+> 附属脚本表达式语法
+> *subscript-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **[** [*expression-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression-list) **]**
 
 
          
 
-> Forced-value 表达式语法  
-> *forced-value-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **!**  
+> Forced-value 表达式语法
+> *forced-value-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **!**
 
 
          
 
-> 可选链表达式语法  
-> *optional-chaining-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **?**  
+> 可选链表达式语法
+> *optional-chaining-expression* → [*postfix-expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/postfix-expression) **?**
 
-
+
 ## 词法结构
 
-> 标识符语法  
-> *identifier* → [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_  
-> *identifier* → **`** [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_ **`**  
-> *identifier* → [*implicit-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/implicit-parameter-name)  
-> *identifier-list* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **,** [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list)  
-> *identifier-head* → Upper- or lowercase letter A through Z  
-> *identifier-head* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA  
-> *identifier-head* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF  
-> *identifier-head* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF  
-> *identifier-head* → U+1E00–U+1FFF  
-> *identifier-head* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F  
-> *identifier-head* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793  
-> *identifier-head* → U+2C00–U+2DFF or U+2E80–U+2FFF  
-> *identifier-head* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF  
-> *identifier-head* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44  
-> *identifier-head* → U+FE47–U+FFFD  
-> *identifier-head* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD  
-> *identifier-head* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD  
-> *identifier-head* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD  
-> *identifier-head* → U+D0000–U+DFFFD or U+E0000–U+EFFFD  
-> *identifier-character* → Digit 0 through 9  
-> *identifier-character* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F  
-> *identifier-character* → [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head)  
-> *identifier-characters* → [*identifier-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-character) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_  
-> *implicit-parameter-name* → **$** [*decimal-digits*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits)  
+> 标识符语法
+> *identifier* → [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_
+> *identifier* → **`** [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_ **`**
+> *identifier* → [*implicit-parameter-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/implicit-parameter-name)
+> *identifier-list* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) | [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier) **,** [*identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-list)
+> *identifier-head* → Upper- or lowercase letter A through Z
+> *identifier-head* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
+> *identifier-head* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
+> *identifier-head* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
+> *identifier-head* → U+1E00–U+1FFF
+> *identifier-head* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
+> *identifier-head* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
+> *identifier-head* → U+2C00–U+2DFF or U+2E80–U+2FFF
+> *identifier-head* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
+> *identifier-head* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
+> *identifier-head* → U+FE47–U+FFFD
+> *identifier-head* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
+> *identifier-head* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
+> *identifier-head* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
+> *identifier-head* → U+D0000–U+DFFFD or U+E0000–U+EFFFD
+> *identifier-character* → Digit 0 through 9
+> *identifier-character* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
+> *identifier-character* → [*identifier-head*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-head)
+> *identifier-characters* → [*identifier-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-character) [*identifier-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier-characters) _opt_
+> *implicit-parameter-name* → **$** [*decimal-digits*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits)
 
 
          
 
-> 字面量语法  
-> *literal* → [*integer-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/integer-literal) | [*floating-point-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-literal) | [*string-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/string-literal)  
+> 字面量语法
+> *literal* → [*integer-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/integer-literal) | [*floating-point-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-literal) | [*string-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/string-literal)
 
 
          
 
-> 整形字面量语法  
-> *integer-literal* → [*binary-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal)  
-> *integer-literal* → [*octal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal)  
-> *integer-literal* → [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)  
-> *integer-literal* → [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)  
-> *binary-literal* → **0b** [*binary-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit) [*binary-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) _opt_  
-> *binary-digit* → Digit 0 or 1  
-> *binary-literal-character* → [*binary-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit) | **_**  
-> *binary-literal-characters* → [*binary-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-character) [*binary-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) _opt_  
-> *octal-literal* → **0o** [*octal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit) [*octal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) _opt_  
-> *octal-digit* → Digit 0 through 7  
-> *octal-literal-character* → [*octal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit) | **_**  
-> *octal-literal-characters* → [*octal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-character) [*octal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) _opt_  
-> *decimal-literal* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [*decimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) _opt_  
-> *decimal-digit* → Digit 0 through 9  
-> *decimal-digits* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [*decimal-digits*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits) _opt_  
-> *decimal-literal-character* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) | **_**  
-> *decimal-literal-characters* → [*decimal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-character) [*decimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) _opt_  
-> *hexadecimal-literal* → **0x** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) _opt_  
-> *hexadecimal-digit* → Digit 0 through 9, a through f, or A through F  
-> *hexadecimal-literal-character* → [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) | **_**  
-> *hexadecimal-literal-characters* → [*hexadecimal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-character) [*hexadecimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) _opt_  
+> 整形字面量语法
+> *integer-literal* → [*binary-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal)
+> *integer-literal* → [*octal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal)
+> *integer-literal* → [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)
+> *integer-literal* → [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)
+> *binary-literal* → **0b** [*binary-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit) [*binary-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) _opt_
+> *binary-digit* → Digit 0 or 1
+> *binary-literal-character* → [*binary-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-digit) | **_**
+> *binary-literal-characters* → [*binary-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-character) [*binary-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/binary-literal-characters) _opt_
+> *octal-literal* → **0o** [*octal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit) [*octal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) _opt_
+> *octal-digit* → Digit 0 through 7
+> *octal-literal-character* → [*octal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-digit) | **_**
+> *octal-literal-characters* → [*octal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-character) [*octal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/octal-literal-characters) _opt_
+> *decimal-literal* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [*decimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) _opt_
+> *decimal-digit* → Digit 0 through 9
+> *decimal-digits* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) [*decimal-digits*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digits) _opt_
+> *decimal-literal-character* → [*decimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-digit) | **_**
+> *decimal-literal-characters* → [*decimal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-character) [*decimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal-characters) _opt_
+> *hexadecimal-literal* → **0x** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) _opt_
+> *hexadecimal-digit* → Digit 0 through 9, a through f, or A through F
+> *hexadecimal-literal-character* → [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) | **_**
+> *hexadecimal-literal-characters* → [*hexadecimal-literal-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-character) [*hexadecimal-literal-characters*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal-characters) _opt_
 
 
          
 
-> 浮点型字面量语法  
-> *floating-point-literal* → [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal) [*decimal-fraction*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-fraction) _opt_ [*decimal-exponent*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-exponent) _opt_  
-> *floating-point-literal* → [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) [*hexadecimal-fraction*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-fraction) _opt_ [*hexadecimal-exponent*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-exponent)  
-> *decimal-fraction* → **.** [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)  
-> *decimal-exponent* → [*floating-point-e*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-e) [*sign*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) _opt_ [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)  
-> *hexadecimal-fraction* → **.** [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) _opt_  
-> *hexadecimal-exponent* → [*floating-point-p*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-p) [*sign*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) _opt_ [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)  
-> *floating-point-e* → **e** | **E**  
-> *floating-point-p* → **p** | **P**  
-> *sign* → **+** | **-**  
+> 浮点型字面量语法
+> *floating-point-literal* → [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal) [*decimal-fraction*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-fraction) _opt_ [*decimal-exponent*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-exponent) _opt_
+> *floating-point-literal* → [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) [*hexadecimal-fraction*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-fraction) _opt_ [*hexadecimal-exponent*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-exponent)
+> *decimal-fraction* → **.** [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)
+> *decimal-exponent* → [*floating-point-e*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-e) [*sign*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) _opt_ [*decimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/decimal-literal)
+> *hexadecimal-fraction* → **.** [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal) _opt_
+> *hexadecimal-exponent* → [*floating-point-p*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/floating-point-p) [*sign*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/sign) _opt_ [*hexadecimal-literal*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-literal)
+> *floating-point-e* → **e** | **E**
+> *floating-point-p* → **p** | **P**
+> *sign* → **+** | **-**
 
 
          
 
-> 字符型字面量语法  
-> *string-literal* → **"** [*quoted-text*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) **"**  
-> *quoted-text* → [*quoted-text-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text-item) [*quoted-text*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) _opt_  
-> *quoted-text-item* → [*escaped-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/escaped-character)  
-> *quoted-text-item* → **\(** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **)**  
-> *quoted-text-item* → Any Unicode extended grapheme cluster except "­, \­, U+000A, or U+000D  
-> *escaped-character* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**  
-> *escaped-character* → **\x** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)  
-> *escaped-character* → **\u** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)  
-> *escaped-character* → **\U** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)  
+> 字符型字面量语法
+> *string-literal* → **"** [*quoted-text*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) **"**
+> *quoted-text* → [*quoted-text-item*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text-item) [*quoted-text*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/quoted-text) _opt_
+> *quoted-text-item* → [*escaped-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/escaped-character)
+> *quoted-text-item* → **\(** [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression) **)**
+> *quoted-text-item* → Any Unicode extended grapheme cluster except "­, \­, U+000A, or U+000D
+> *escaped-character* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
+> *escaped-character* → **\x** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
+> *escaped-character* → **\u** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
+> *escaped-character* → **\U** [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit) [*hexadecimal-digit*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/hexadecimal-digit)
 
 
          
 
-> 运算符语法语法  
-> *operator* → [*operator-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator-character) [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) _opt_  
-> *operator-character* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**  
-> *binary-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)  
-> *prefix-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)  
-> *postfix-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)  
+> 运算符语法语法
+> *operator* → [*operator-character*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator-character) [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator) _opt_
+> *operator-character* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**
+> *binary-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
+> *prefix-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
+> *postfix-operator* → [*operator*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/operator)
 
-
+
 ## 类型
 
-> 类型语法  
-> *type* → [*array-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/array-type) | [*function-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/function-type) | [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) | [*tuple-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type) | [*optional-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/optional-type) | [*implicitly-unwrapped-optional-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/implicitly-unwrapped-optional-type) | [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type) | [*metatype-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/metatype-type)  
+> 类型语法
+> *type* → [*array-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/array-type) | [*function-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/function-type) | [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) | [*tuple-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type) | [*optional-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/optional-type) | [*implicitly-unwrapped-optional-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/implicitly-unwrapped-optional-type) | [*protocol-composition-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-composition-type) | [*metatype-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/metatype-type)
 
 
          
 
-> 类型标注语法  
-> *type-annotation* → **:** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 类型标注语法
+> *type-annotation* → **:** [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 类型标识语法  
-> *type-identifier* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_ | [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_ **.** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)  
-> *type-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 类型标识语法
+> *type-identifier* → [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_ | [*type-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-name) [*generic-argument-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html#//apple_ref/swift/grammar/generic-argument-clause) _opt_ **.** [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)
+> *type-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 元组类型语法  
-> *tuple-type* → **(** [*tuple-type-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-body) _opt_ **)**  
-> *tuple-type-body* → [*tuple-type-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element-list) **...** _opt_  
-> *tuple-type-element-list* → [*tuple-type-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element) | [*tuple-type-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element) **,** [*tuple-type-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element-list)  
-> *tuple-type-element* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **inout** _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) | **inout** _opt_ [*element-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/element-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation)  
-> *element-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)  
+> 元组类型语法
+> *tuple-type* → **(** [*tuple-type-body*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-body) _opt_ **)**
+> *tuple-type-body* → [*tuple-type-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element-list) **...** _opt_
+> *tuple-type-element-list* → [*tuple-type-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element) | [*tuple-type-element*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element) **,** [*tuple-type-element-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/tuple-type-element-list)
+> *tuple-type-element* → [*attributes*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Attributes.html#//apple_ref/swift/grammar/attributes) _opt_ **inout** _opt_ [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) | **inout** _opt_ [*element-name*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/element-name) [*type-annotation*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-annotation)
+> *element-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
 
          
 
-> 函数类型语法  
-> *function-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **->** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)  
+> 函数类型语法
+> *function-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **->** [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type)
 
 
          
 
-> 数组类型语法  
-> *array-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **[** **]** | [*array-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/array-type) **[** **]**  
+> 数组类型语法
+> *array-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **[** **]** | [*array-type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/array-type) **[** **]**
 
 
          
 
-> 可选类型语法  
-> *optional-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **?**  
+> 可选类型语法
+> *optional-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **?**
 
 
          
 
-> 隐式解析可选类型语法  
-> *implicitly-unwrapped-optional-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **!**  
+> 隐式解析可选类型语法
+> *implicitly-unwrapped-optional-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **!**
 
 
          
 
-> 协议合成类型语法  
-> *protocol-composition-type* → **protocol** **<** [*protocol-identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier-list) _opt_ **>**  
-> *protocol-identifier-list* → [*protocol-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier) | [*protocol-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier) **,** [*protocol-identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier-list)  
-> *protocol-identifier* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)  
+> 协议合成类型语法
+> *protocol-composition-type* → **protocol** **<** [*protocol-identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier-list) _opt_ **>**
+> *protocol-identifier-list* → [*protocol-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier) | [*protocol-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier) **,** [*protocol-identifier-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/protocol-identifier-list)
+> *protocol-identifier* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier)
 
 
          
 
-> 元类型语法  
-> *metatype-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **.** **Type** | [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **.** **Protocol**  
+> 元类型语法
+> *metatype-type* → [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **.** **Type** | [*type*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type) **.** **Protocol**
 
 
          
 
-> 类型继承子句语法  
-> *type-inheritance-clause* → **:** [*type-inheritance-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-list)  
+> 类型继承子句语法
+> *type-inheritance-clause* → **:** [*type-inheritance-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-list)
 > *type-inheritance-list* → [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) | [*type-identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-identifier) **,** [*type-inheritance-list*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Types.html#//apple_ref/swift/grammar/type-inheritance-list)
diff --git a/source/chapter3/10_Statements.md b/source/chapter3/10_Statements.md
index db5273df..8d32eae7 100644
--- a/source/chapter3/10_Statements.md
+++ b/source/chapter3/10_Statements.md
@@ -1,6 +1,17 @@
+> 翻译：coverxit
+
+> 校对：numbbbbb
+
 # 语句
 -----------------
 
+本页包含内容：
+
+- [循环语句](#loop_statements)
+- [分支语句](#branch_statements)
+- [带标签的语句](#labeled_statement)
+- [控制传递语句](#control_transfer_statements)
+
 在 Swift 中，有两种类型的语句：简单语句和控制流语句。简单语句是最常见的，用于构造表达式和声明。控制流语句则用于控制程序执行的流程，Swift 中有三种类型的控制流语句：循环语句、分支语句和控制传递语句。
 
 循环语句用于重复执行代码块；分支语句用于执行满足特定条件的代码块；控制传递语句则用于修改代码的执行顺序。在稍后的叙述中，将会详细地介绍每一种类型的控制流语句。
@@ -23,6 +34,7 @@
 
 > *statement* → [*statment*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statement) [*statements*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/statements)**;** *opt*
 
+
 ## 循环语句
 
 取决于特定的循环条件，循环语句允许重复执行代码块。Swift 提供四种类型的循环语句：`for`语句、`for-in`语句、`while`语句和`do-while`语句。
@@ -44,7 +56,7 @@
 `for`语句允许在重复执行代码块的同时，递增一个计数器。
 
 `for`语句的形式如下：
-	
+
 ```swift
 for `initialzation`; `condition`; `increment` {
 	`statements`
@@ -77,7 +89,7 @@ for `initialzation`; `condition`; `increment` {
 `for-in`语句允许在重复执行代码块的同时，迭代集合(或遵循`Sequence`协议的任意类型)中的每一项。
 
 `for-in`语句的形式如下：
-	
+
 ```swift
 for `item` in `collection` {
 	`statements`
@@ -95,7 +107,7 @@ for `item` in `collection` {
 `while`语句允许重复执行代码块。
 
 `while`语句的形式如下：
-	
+
 ```swift
 while `condition` {
 	`statements`
@@ -124,7 +136,7 @@ while `condition` {
 `do-while`语句允许代码块被执行一次或多次。
 
 `do-while`语句的形式如下：
-	
+
 ```swift
 do {
 	`statements`
@@ -144,8 +156,9 @@ do {
 
 > GRAMMAR OF A DO-WHILE STATEMENT
 
-> *do-while-statement* → **do** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition) 
+> *do-while-statement* → **do** [*code-block*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/code-block) **while** [*while-condition*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Statements.html#//apple_ref/swift/grammar/while-condition)
 
+
 ## 分支语句
 
 取决于一个或者多个条件的值，分支语句允许程序执行指定部分的代码。显然，分支语句中条件的值将会决定如何分支以及执行哪一块代码。Swift 提供两种类型的分支语句：`if`语句和`switch`语句。
@@ -270,7 +283,8 @@ case let (x, y) where x == y:
 
 > *guard-expression* → [*expression*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Expressions.html#//apple_ref/swift/grammar/expression)
 
-## 带标签的语句
+
+ 带标签的语句
 
 你可以在循环语句或`switch`语句前面加上*标签*，它由标签名和紧随其后的冒号(:)组成。在`break`和`continue`后面跟上标签名可以显式地在循环语句或`switch`语句中更改控制流，把控制权传递给指定标签标记的语句。关于这两条语句用法，请参考[Break 语句](#break_statement)和[Continue 语句](#continue_statement)。
 
@@ -286,6 +300,7 @@ case let (x, y) where x == y:
 
 > *label-name* → [*identifier*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/swift/grammar/identifier)
 
+
 ## 控制传递语句
 
 通过无条件地把控制权从一片代码传递到另一片代码，控制传递语句能够改变代码执行的顺序。Swift 提供四种类型的控制传递语句：`break`语句、`continue`语句、`fallthrough`语句和`return`语句。