andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

make gitbook

Browse Source
This commit is contained in:
numbbbbb
2014-06-14 23:24:20 +08:00
parent a0489eef96
commit 4634005f9c
42 changed files with 981 additions and 1046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
chapter2/01_The_Basics.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.1" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.1" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_37">
<section class="normal" id="section-gitbook_513">
<blockquote>
<p>翻译：numbbbbb, lyuka, JaySurplus<br>校对：lslxdx </p>

4
chapter2/02_Basic_Operators.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.2" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.2" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_55">
<section class="normal" id="section-gitbook_534">
<blockquote>
<p>翻译：xielingwang<br>校对：Evilcome </p>

4
chapter2/03_Strings_and_Characters.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.3" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.3" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_39">
<section class="normal" id="section-gitbook_515">
<blockquote>
<p>翻译：wh1100717<br>校对：Hawstein </p>

4
chapter2/04_Collection_Types.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.4" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.4" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_41">
<section class="normal" id="section-gitbook_517">
<blockquote>
<p>翻译：zqp

4
chapter2/05_Control_Flow.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.5" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.5" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_43">
<section class="normal" id="section-gitbook_519">
<blockquote>
<p>翻译：vclwei, coverxit, NicePiao<br>校对：coverxit, stanzhai</p>

6
chapter2/06_Functions.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.6" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.6" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_45">
<section class="normal" id="section-gitbook_521">
<blockquote>
<p>翻译：honghaoz<br>校对：LunaticM </p>
@ -603,7 +603,7 @@
<li><a href="#Nested_Functions">函数嵌套（Nested Functions）</a></li>
</ul>
<p>函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标示函数做什么，并且当函数需要执行的时候，这个名字会被“调用”。</p>
<p>Swift 统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以即当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。</p>
<p>Swift 统一的函数语法足够灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值，以简化函数调用。参数也可以既当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值可以被修改。</p>
<p>在 Swift 中，每个函数都有一种类型，包括函数的参数值类型和返回值类型。你可以把函数类型当做任何其他普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。</p>
<p><a name="Defining_and_Calling_Functions"></a></p>
<h2 id="-defining-and-calling-functions-">函数的定义与调用（Defining and Calling Functions）</h2>

4
chapter2/07_Closures.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.7" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.7" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_47">
<section class="normal" id="section-gitbook_523">
<blockquote>
<p>翻译：wh1100717<br>校对：lyuka </p>

4
chapter2/08_Enumerations.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.8" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.8" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_49">
<section class="normal" id="section-gitbook_525">
<blockquote>
<p>翻译：yankuangshi<br>校对：shinyzhu </p>

4
chapter2/09_Classes_and_Structures.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.9" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.9" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_59">
<section class="normal" id="section-gitbook_527">
<blockquote>
<p>翻译：JaySurplus<br>校对：sg552 </p>

4
chapter2/10_Properties.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.10" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.10" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_57">
<section class="normal" id="section-gitbook_528">
<blockquote>
<p>翻译：shinyzhu<br>校对：pp-prog </p>

4
chapter2/11_Methods.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.11" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.11" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_51">
<section class="normal" id="section-gitbook_530">
<blockquote>
<p>翻译：pp-prog<br>校对：zqp </p>

4
chapter2/12_Subscripts.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.12" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.12" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_53">
<section class="normal" id="section-gitbook_532">
<blockquote>
<p>翻译：siemenliu<br>校对：zq54zquan </p>

4
chapter2/13_Inheritance.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.13" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.13" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_35">
<section class="normal" id="section-gitbook_511">
<blockquote>
<p>翻译：Hawstein<br>校对：menlongsheng </p>

4
chapter2/14_Initialization.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.14" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.14" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_60">
<section class="normal" id="section-gitbook_536">
<blockquote>
<p>翻译：lifedim<br>校对：lifedim </p>

4
chapter2/15_Deinitialization.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.15" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.15" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_62">
<section class="normal" id="section-gitbook_538">
<blockquote>
<p>翻译：bruce0505<br>校对：fd5788 </p>

217
chapter2/16_Automatic_Reference_Counting.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.16" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.16" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_64">
<section class="normal" id="section-gitbook_540">
<blockquote>
<p>翻译：TimothyYe</p>
<p>校对：Hawstein</p>
<p>翻译：TimothyYe<br>校对：Hawstein </p>
</blockquote>
<h1 id="-">自动引用计数</h1>
<hr>
@ -607,8 +606,7 @@
<p>Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。</p>
<p>然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。</p>
<blockquote>
<p>注意:</p>
<p>引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。</p>
<p>注意:<br>引用计数仅仅应用于类的实例。结构体和枚举类型是值类型，不是引用类型，也不是通过引用的方式存储和传递。</p>
</blockquote>
<p><a name="how_arc_works"></a></p>
<h2 id="-">自动引用计数的工作机制</h2>
@ -619,77 +617,86 @@
<p><a name="arc_in_action"></a></p>
<h2 id="-">自动引用计数实践</h2>
<p>下面的例子展示了自动引用计数的工作机制。例子以一个简单的<code>Person</code>类开始，并定义了一个叫<code>name</code>的常量属性：</p>
<pre><code> class Person {
let name: String
init(name: String) {
self.name = name
println(&quot;\(name) is being initialized&quot;)
}
deinit {
println(&quot;\(name) is being deinitialized&quot;)
}
<pre><code class="lang-swift">class Person {
let name: String
init(name: String) {
self.name = name
println(&quot;\(name) is being initialized&quot;)
}
</code></pre><p><code>Person</code>类有一个构造函数，此构造函数为实例的<code>name</code>属性赋值并打印出信息，以表明初始化过程生效。<code>Person</code>类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。</p>
deinit {
println(&quot;\(name) is being deinitialized&quot;)
}
}
</code></pre>
<p><code>Person</code>类有一个构造函数，此构造函数为实例的<code>name</code>属性赋值并打印出信息，以表明初始化过程生效。<code>Person</code>类同时也拥有析构函数，同样会在实例被销毁的时候打印出信息。</p>
<p>接下来的代码片段定义了三个类型为<code>Person?</code>的变量，用来按照代码片段中的顺序，为新的<code>Person</code>实例建立多个引用。由于这些变量是被定义为可选类型（Person?，而不是Person），它们的值会被自动初始化为<code>nil</code>，目前还不会引用到<code>Person</code>类的实例。</p>
<pre><code> var reference1: Person?
var reference2: Person?
var reference3: Person?
</code></pre><p>现在你可以创建<code>Person</code>类的新实例，并且将它赋值给三个变量其中的一个：</p>
<pre><code> reference1 = Person(name: &quot;John Appleseed&quot;)
// prints &quot;John Appleseed is being initialized”
</code></pre><p>应当注意到当你调用<code>Person</code>类的构造函数的时候，&quot;John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。</p>
<pre><code class="lang-swift">var reference1: Person?
var reference2: Person?
var reference3: Person?
</code></pre>
<p>现在你可以创建<code>Person</code>类的新实例，并且将它赋值给三个变量其中的一个：</p>
<pre><code class="lang-swift">reference1 = Person(name: &quot;John Appleseed&quot;)
// prints &quot;John Appleseed is being initialized”
</code></pre>
<p>应当注意到当你调用<code>Person</code>类的构造函数的时候，&quot;John Appleseed is being initialized”会被打印出来。由此可以确定构造函数被执行。</p>
<p>由于<code>Person</code>类的新实例被赋值给了<code>reference1</code>变量，所以<code>reference1</code>到<code>Person</code>类的新实例之间建立了一个强引用。正是因为这个强引用，ARC 会保证<code>Person</code>实例被保持在内存中不被销毁。</p>
<p>如果你将同样的<code>Person</code>实例也赋值给其他两个变量，该实例又会多出两个强引用：</p>
<pre><code> reference2 = reference1
reference3 = reference1
</code></pre><p>现在这个<code>Person</code>实例已经有三个强引用了。</p>
<pre><code class="lang-swift">reference2 = reference1
reference3 = reference1
</code></pre>
<p>现在这个<code>Person</code>实例已经有三个强引用了。</p>
<p>如果你通过给两个变量赋值<code>nil</code>的方式断开两个强引用（）包括最先的那个强引用），只留下一个强引用，<code>Person</code>实例不会被销毁：</p>
<pre><code>reference2 = nil
<pre><code class="lang-swift">reference2 = nil
reference3 = nil
</code></pre><p>ARC 会在第三个，也即最后一个强引用被断开的时候，销毁<code>Person</code>实例，这也意味着你不再使用这个<code>Person</code>实例：</p>
<pre><code>reference3 = nil
</code></pre>
<p>ARC 会在第三个，也即最后一个强引用被断开的时候，销毁<code>Person</code>实例，这也意味着你不再使用这个<code>Person</code>实例：</p>
<pre><code class="lang-swift">reference3 = nil
// prints &quot;John Appleseed is being deinitialized&quot;
</code></pre><p><a name="strong_reference_cycles_between_class_instances"></a></p>
</code></pre>
<p><a name="strong_reference_cycles_between_class_instances"></a></p>
<h2 id="-">类实例之间的循环强引用</h2>
<p>在上面的例子中，ARC 会跟踪你所新创建的<code>Person</code>实例的引用数量，并且会在<code>Person</code>实例不再被需要时销毁它。</p>
<p>然而，我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。</p>
<p>你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在<a href="#resolving_strong_reference_cycles_between_class_instances">解决类实例之间的循环强引用</a>中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。</p>
<p>下面展示了一个不经意产生循环强引用的例子。例子定义了两个类：<code>Person</code>和<code>Apartment</code>，用来建模公寓和它其中的居民:</p>
<pre><code>class Person {
<pre><code class="lang-swift">class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println(&quot;\(name) is being deinitialized&quot;) }
}
class Apartment {
</code></pre>
<pre><code class="lang-swift">class Apartment {
let number: Int
init(number: Int) { self.number = number }
var tenant: Person?
deinit { println(&quot;Apartment #\(number) is being deinitialized&quot;) }
}
</code></pre><p>每一个<code>Person</code>实例有一个类型为<code>String</code>，名字为<code>name</code>的属性，并有一个可选的初始化为<code>nil</code>的<code>apartment</code>属性。<code>apartment</code>属性是可选的，因为一个人并不总是拥有公寓。</p>
</code></pre>
<p>每一个<code>Person</code>实例有一个类型为<code>String</code>，名字为<code>name</code>的属性，并有一个可选的初始化为<code>nil</code>的<code>apartment</code>属性。<code>apartment</code>属性是可选的，因为一个人并不总是拥有公寓。</p>
<p>类似的，每个<code>Apartment</code>实例有一个叫<code>number</code>，类型为<code>Int</code>的属性，并有一个可选的初始化为<code>nil</code>的<code>tenant</code>属性。<code>tenant</code>属性是可选的，因为一栋公寓并不总是有居民。</p>
<p>这两个类都定义了析构函数，用以在类实例被析构的时候输出信息。这让你能够知晓<code>Person</code>和<code>Apartment</code>的实例是否像预期的那样被销毁。</p>
<p>接下来的代码片段定义了两个可选类型的变量<code>john</code>和<code>number73</code>,并分别被设定为下面的<code>Apartment</code>和<code>Person</code>的实例。这两个变量都被初始化为<code>nil</code>，并为可选的：</p>
<pre><code>var john: Person?
<pre><code class="lang-swift">var john: Person?
var number73: Apartment?
</code></pre><p>现在你可以创建特定的<code>Person</code>和<code>Apartment</code>实例并将类实例赋值给<code>john</code>和<code>number73</code>变量：</p>
<pre><code>john = Person(name: &quot;John Appleseed&quot;)
</code></pre>
<p>现在你可以创建特定的<code>Person</code>和<code>Apartment</code>实例并将类实例赋值给<code>john</code>和<code>number73</code>变量：</p>
<pre><code class="lang-swift">john = Person(name: &quot;John Appleseed&quot;)
number73 = Apartment(number: 73)
</code></pre><p>在两个实例被创建和赋值后，下图表现了强引用的关系。变量<code>john</code>现在有一个指向<code>Person</code>实例的强引用，而变量<code>number73</code>有一个指向<code>Apartment</code>实例的强引用：</p>
</code></pre>
<p>在两个实例被创建和赋值后，下图表现了强引用的关系。变量<code>john</code>现在有一个指向<code>Person</code>实例的强引用，而变量<code>number73</code>有一个指向<code>Apartment</code>实例的强引用：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle01_2x.png" alt=""></p>
<p>现在你能够将这两个实例关联在一起，这样人就能有公寓住了，而公寓也有了房客。注意感叹号是用来展开和访问可选变量<code>john</code>和<code>number73</code>中的实例，这样实例的属性才能被赋值：</p>
<pre><code>john!.apartment = number73
<pre><code class="lang-swift">john!.apartment = number73
number73!.tenant = john
</code></pre><p>在将两个实例联系在一起之后，强引用的关系如图所示：</p>
</code></pre>
<p>在将两个实例联系在一起之后，强引用的关系如图所示：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle02_2x.png" alt=""></p>
<p>不幸的是，将这两个实例关联在一起之后，一个循环强引用被创建了。<code>Person</code>实例现在有了一个指向<code>Apartment</code>实例的强引用，而<code>Apartment</code>实例也有了一个指向<code>Person</code>实例的强引用。因此，当你断开<code>john</code>和<code>number73</code>变量所持有的强引用时，引用计数并不会降为 0，实例也不会被 ARC 销毁：</p>
<pre><code>john = nil
<pre><code class="lang-swift">john = nil
number73 = nil
</code></pre><p>注意，当你把这两个变量设为<code>nil</code>时，没有任何一个析构函数被调用。强引用循环阻止了<code>Person</code>和<code>Apartment</code>类实例的销毁，并在你的应用程序中造成了内存泄漏。</p>
</code></pre>
<p>注意，当你把这两个变量设为<code>nil</code>时，没有任何一个析构函数被调用。强引用循环阻止了<code>Person</code>和<code>Apartment</code>类实例的销毁，并在你的应用程序中造成了内存泄漏。</p>
<p>在你将<code>john</code>和<code>number73</code>赋值为<code>nil</code>后，强引用关系如下图：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/referenceCycle03_2x.png" alt=""></p>
<p><code>Person</code>和<code>Apartment</code>实例之间的强引用关系保留了下来并且不会被断开。</p>
@ -702,27 +709,27 @@ number73 = nil
<p>弱引用不会牢牢保持住引用的实例，并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上<code>weak</code>关键字表明这是一个弱引用。</p>
<p>在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在<a href="#2">无主引用</a>中有描述。在上面<code>Apartment</code>的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。</p>
<blockquote>
<p>注意:
弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。</p>
<p>注意:<br>弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。 </p>
</blockquote>
<p>因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。</p>
<p>因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为<code>nil</code>。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。</p>
<p>下面的例子跟上面<code>Person</code>和<code>Apartment</code>的例子一致，但是有一个重要的区别。这一次，<code>Apartment</code>的<code>tenant</code>属性被声明为弱引用：</p>
<pre><code>class Person {
<pre><code class="lang-swift">class Person {
let name: String
init(name: String) { self.name = name }
var apartment: Apartment?
deinit { println(&quot;\(name) is being deinitialized&quot;) }
}
class Apartment {
</code></pre>
<pre><code class="lang-swift">class Apartment {
let number: Int
init(number: Int) { self.number = number }
weak var tenant: Person?
deinit { println(&quot;Apartment #\(number) is being deinitialized&quot;) }
}
</code></pre><p>然后跟之前一样，建立两个变量（john和number73）之间的强引用，并关联两个实例：</p>
<pre><code>var john: Person?
</code></pre>
<p>然后跟之前一样，建立两个变量（john和number73）之间的强引用，并关联两个实例：</p>
<pre><code class="lang-swift">var john: Person?
var number73: Apartment?
john = Person(name: &quot;John Appleseed&quot;)
@ -730,33 +737,34 @@ number73 = Apartment(number: 73)
john!.apartment = number73
number73!.tenant = john
</code></pre><p>现在，两个关联在一起的实例的引用关系如下图所示：</p>
</code></pre>
<p>现在，两个关联在一起的实例的引用关系如下图所示：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference01_2x.png" alt=""></p>
<p><code>Person</code>实例依然保持对<code>Apartment</code>实例的强引用，但是<code>Apartment</code>实例只是对<code>Person</code>实例的弱引用。这意味着当你断开<code>john</code>变量所保持的强引用时，再也没有指向<code>Person</code>实例的强引用了：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference02_2x.png" alt=""></p>
<p>由于再也没有指向<code>Person</code>实例的强引用，该实例会被销毁：</p>
<pre><code>john = nil
<pre><code class="lang-swift">john = nil
// prints &quot;John Appleseed is being deinitialized&quot;
</code></pre><p>唯一剩下的指向<code>Apartment</code>实例的强引用来自于变量<code>number73</code>。如果你断开这个强引用，再也没有指向<code>Apartment</code>实例的强引用了：</p>
</code></pre>
<p>唯一剩下的指向<code>Apartment</code>实例的强引用来自于变量<code>number73</code>。如果你断开这个强引用，再也没有指向<code>Apartment</code>实例的强引用了：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/weakReference03_2x.png" alt=""></p>
<p>由于再也没有指向<code>Apartment</code>实例的强引用，该实例也会被销毁：</p>
<pre><code>number73 = nil
<pre><code class="lang-swift">number73 = nil
// prints &quot;Apartment #73 is being deinitialized&quot;
</code></pre><p>上面的两段代码展示了变量<code>john</code>和<code>number73</code>在被赋值为<code>nil</code>后，<code>Person</code>实例和<code>Apartment</code>实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。</p>
</code></pre>
<p>上面的两段代码展示了变量<code>john</code>和<code>number73</code>在被赋值为<code>nil</code>后，<code>Person</code>实例和<code>Apartment</code>实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。</p>
<p><a name="2"></a></p>
<h3 id="-">无主引用</h3>
<p>和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用是永远有值的。因此，无主引用总是被定义为非可选类型（non-optional type）。你可以在声明属性或者变量时，在前面加上关键字<code>unowned</code>表示这是一个无主引用。</p>
<p>由于无主引用是非可选类型，你不需要在使用它的时候将它展开。无主引用总是可以被直接访问。不过 ARC 无法在实例被销毁后将无主引用设为<code>nil</code>，因为非可选类型的变量不允许被赋值为<code>nil</code>。</p>
<blockquote>
<p>注意:
如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。</p>
<p>还需要注意的是如果你试图访问实例已经被销毁的无主引用，程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。</p>
<p>注意:<br>如果你试图在实例被销毁后，访问该实例的无主引用，会触发运行时错误。使用无主引用，你必须确保引用始终指向一个未销毁的实例。<br>还需要注意的是如果你试图访问实例已经被销毁的无主引用，程序会直接崩溃，而不会发生无法预期的行为。所以你应当避免这样的事情发生。 </p>
</blockquote>
<p>下面的例子定义了两个类，<code>Customer</code>和<code>CreditCard</code>，模拟了银行客户和客户的信用卡。这两个类中，每一个都将另外一个类的实例作为自身的属性。这种关系会潜在的创造循环强引用。</p>
<p><code>Customer</code>和<code>CreditCard</code>之间的关系与前面弱引用例子中<code>Apartment</code>和<code>Person</code>的关系截然不同。在这个数据模型中，一个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。为了表示这种关系，<code>Customer</code>类有一个可选类型的<code>card</code>属性，但是<code>CreditCard</code>类有一个非可选类型的<code>customer</code>属性。</p>
<p>此外，只能通过将一个<code>number</code>值和<code>customer</code>实例传递给<code>CreditCard</code>构造函数的方式来创建<code>CreditCard</code>实例。这样可以确保当创建<code>CreditCard</code>实例时总是有一个<code>customer</code>实例与之关联。</p>
<p>由于信用卡总是关联着一个客户，因此将<code>customer</code>属性定义为无主引用，用以避免循环强引用：</p>
<pre><code>class Customer {
<pre><code class="lang-swift">class Customer {
let name: String
var card: CreditCard?
init(name: String) {
@ -764,8 +772,8 @@ number73!.tenant = john
}
deinit { println(&quot;\(name) is being deinitialized&quot;) }
}
class CreditCard {
</code></pre>
<pre><code class="lang-swift">class CreditCard {
let number: Int
unowned let customer: Customer
init(number: Int, customer: Customer) {
@ -774,21 +782,25 @@ class CreditCard {
}
deinit { println(&quot;Card #\(number) is being deinitialized&quot;) }
}
</code></pre><p>下面的代码片段定义了一个叫<code>john</code>的可选类型<code>Customer</code>变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为<code>nil</code>。</p>
<pre><code>var john: Customer?
</code></pre><p>现在你可以创建<code>Customer</code>类的实例，用它初始化<code>CreditCard</code>实例，并将新创建的<code>CreditCard</code>实例赋值为客户的<code>card</code>属性。</p>
<pre><code>john = Customer(name: &quot;John Appleseed&quot;)
</code></pre>
<p>下面的代码片段定义了一个叫<code>john</code>的可选类型<code>Customer</code>变量，用来保存某个特定客户的引用。由于是可选类型，所以变量被初始化为<code>nil</code>。</p>
<pre><code class="lang-swift">var john: Customer?
</code></pre>
<p>现在你可以创建<code>Customer</code>类的实例，用它初始化<code>CreditCard</code>实例，并将新创建的<code>CreditCard</code>实例赋值为客户的<code>card</code>属性。</p>
<pre><code class="lang-swift">john = Customer(name: &quot;John Appleseed&quot;)
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
</code></pre><p>在你关联两个实例后，它们的引用关系如下图所示：</p>
</code></pre>
<p>在你关联两个实例后，它们的引用关系如下图所示：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/unownedReference01_2x.png" alt=""></p>
<p><code>Customer</code>实例持有对<code>CreditCard</code>实例的强引用，而<code>CreditCard</code>实例持有对<code>Customer</code>实例的无主引用。</p>
<p>由于<code>customer</code>的无主引用，当你断开<code>john</code>变量持有的强引用时，再也没有指向<code>Customer</code>实例的强引用了：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/unownedReference02_2x.png" alt=""></p>
<p>由于再也没有指向<code>Customer</code>实例的强引用，该实例被销毁了。其后，再也没有指向<code>CreditCard</code>实例的强引用，该实例也随之被销毁了：</p>
<pre><code>john = nil
<pre><code class="lang-swift">john = nil
// prints &quot;John Appleseed is being deinitialized&quot;
// prints &quot;Card #1234567890123456 is being deinitialized&quot;
</code></pre><p>最后的代码展示了在<code>john</code>变量被设为<code>nil</code>后<code>Customer</code>实例和<code>CreditCard</code>实例的构造函数都打印出了“销毁”的信息。</p>
</code></pre>
<p>最后的代码展示了在<code>john</code>变量被设为<code>nil</code>后<code>Customer</code>实例和<code>CreditCard</code>实例的构造函数都打印出了“销毁”的信息。</p>
<h3 id="-">无主引用以及隐式解析可选属性</h3>
<p>上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。</p>
<p><code>Person</code>和<code>Apartment</code>的例子展示了两个属性的值都允许为<code>nil</code>，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。</p>
@ -796,7 +808,7 @@ john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
<p>然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后不能为<code>nil</code>。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。</p>
<p>这使两个属性在初始化完成后能被直接访问（不需要可选展开），同时避免了循环引用。这一节将为你展示如何建立这种关系。</p>
<p>下面的例子定义了两个类，<code>Country</code>和<code>City</code>，每个类将另外一个类的实例保存为属性。在这个模型中，每个国家必须有首都，而每一个城市必须属于一个国家。为了实现这种关系，<code>Country</code>类拥有一个<code>capitalCity</code>属性，而<code>City</code>类有一个<code>country</code>属性：</p>
<pre><code>class Country {
<pre><code class="lang-swift">class Country {
let name: String
let capitalCity: City!
init(name: String, capitalName: String) {
@ -804,8 +816,8 @@ john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
self.capitalCity = City(name: capitalName, country: self)
}
}
class City {
</code></pre>
<pre><code class="lang-swift">class City {
let name: String
unowned let country: Country
init(name: String, country: Country) {
@ -813,15 +825,17 @@ class City {
self.country = country
}
}
</code></pre><p>为了建立两个类的依赖关系，<code>City</code>的构造函数有一个<code>Country</code>实例的参数，并且将实例保存为<code>country</code>属性。</p>
</code></pre>
<p>为了建立两个类的依赖关系，<code>City</code>的构造函数有一个<code>Country</code>实例的参数，并且将实例保存为<code>country</code>属性。</p>
<p><code>Country</code>的构造函数调用了<code>City</code>的构造函数。然而，只有<code>Country</code>的实例完全初始化完后，<code>Country</code>的构造函数才能把<code>self</code>传给<code>City</code>的构造函数。（<a href="14_Initialization.html">在两段式构造过程中有具体描述</a>）</p>
<p>为了满足这种需求，通过在类型结尾处加上感叹号（City!）的方式，将<code>Country</code>的<code>capitalCity</code>属性声明为隐式解析可选类型的属性。这表示像其他可选类型一样，<code>capitalCity</code>属性的默认值为<code>nil</code>，但是不需要展开它的值就能访问它。（<a href="01_The_Basics.html">在隐式解析可选类型中有描述</a>）</p>
<p>由于<code>capitalCity</code>默认值为<code>nil</code>，一旦<code>Country</code>的实例在构造函数中给<code>name</code>属性赋值后，整个初始化过程就完成了。这代表一旦<code>name</code>属性被赋值后，<code>Country</code>的构造函数就能引用并传递隐式的<code>self</code>。<code>Country</code>的构造函数在赋值<code>capitalCity</code>时，就能将<code>self</code>作为参数传递给<code>City</code>的构造函数。</p>
<p>以上的意义在于你可以通过一条语句同时创建<code>Country</code>和<code>City</code>的实例，而不产生循环强引用，并且<code>capitalCity</code>的属性能被直接访问，而不需要通过感叹号来展开它的可选值：</p>
<pre><code>var country = Country(name: &quot;Canada&quot;, capitalName: &quot;Ottawa&quot;)
<pre><code class="lang-swift">var country = Country(name: &quot;Canada&quot;, capitalName: &quot;Ottawa&quot;)
println(&quot;\(country.name)&#39;s capital city is called \(country.capitalCity.name)&quot;)
// prints &quot;Canada&#39;s capital city is called Ottawa&quot;
</code></pre><p>在上面的例子中，使用隐式解析可选值的意义在于满足了两个类构造函数的需求。<code>capitalCity</code>属性在初始化完成后，能像非可选值一样使用和存取同时还避免了循环强引用。</p>
</code></pre>
<p>在上面的例子中，使用隐式解析可选值的意义在于满足了两个类构造函数的需求。<code>capitalCity</code>属性在初始化完成后，能像非可选值一样使用和存取同时还避免了循环强引用。</p>
<p><a name="strong_reference_cycles_for_closures"></a></p>
<h2 id="-">闭包引起的循环强引用</h2>
<p>前面我们看到了循环强引用环是在两个类实例属性互相保持对方的强引用时产生的，还知道了如何用弱引用和无主引用来打破循环强引用。</p>
@ -829,7 +843,7 @@ println(&quot;\(country.name)&#39;s capital city is called \(country.capitalCity
<p>循环强引用的产生，是因为闭包和类相似，都是引用类型。当你把一个闭包赋值给某个属性时，你也把一个引用赋值给了这个闭包。实质上，这跟之前的问题是一样的－两个强引用让彼此一直有效。但是，和两个类实例不同，这次一个是类实例，另一个是闭包。</p>
<p>Swift 提供了一种优雅的方法来解决这个问题，称之为闭包占用列表（closuer capture list）。同样的，在学习如何用闭包占用列表破坏循环强引用之前，先来了解一下循环强引用是如何产生的，这对我们是很有帮助的。</p>
<p>下面的例子为你展示了当一个闭包引用了<code>self</code>后是如何产生一个循环强引用的。例子中定义了一个叫<code>HTMLElement</code>的类，用一种简单的模型表示 HTML 中的一个单独的元素：</p>
<pre><code>class HTMLElement {
<pre><code class="lang-swift">class HTMLElement {
let name: String
let text: String?
@ -852,61 +866,61 @@ println(&quot;\(country.name)&#39;s capital city is called \(country.capitalCity
}
}
</code></pre><p><code>HTMLElement</code>类定义了一个<code>name</code>属性来表示这个元素的名称，例如代表段落的&quot;p&quot;，或者代表换行的&quot;br&quot;。<code>HTMLElement</code>还定义了一个可选属性<code>text</code>，用来设置和展现 HTML 元素的文本。</p>
</code></pre>
<p><code>HTMLElement</code>类定义了一个<code>name</code>属性来表示这个元素的名称，例如代表段落的&quot;p&quot;，或者代表换行的&quot;br&quot;。<code>HTMLElement</code>还定义了一个可选属性<code>text</code>，用来设置和展现 HTML 元素的文本。</p>
<p>除了上面的两个属性，<code>HTMLElement</code>还定义了一个<code>lazy</code>属性<code>asHTML</code>。这个属性引用了一个闭包，将<code>name</code>和<code>text</code>组合成 HTML 字符串片段。该属性是<code>() -&gt; String</code>类型，或者可以理解为“一个没有参数，返回<code>String</code>的函数”。</p>
<p>默认情况下，闭包赋值给了<code>asHTML</code>属性，这个闭包返回一个代表 HTML 标签的字符串。如果<code>text</code>值存在，该标签就包含可选值<code>text</code>；如果<code>text</code>不存在，该标签就不包含文本。对于段落元素，根据<code>text</code>是&quot;some text&quot;还是<code>nil</code>，闭包会返回&quot;<code>&lt;p&gt;some text&lt;/p&gt;</code>&quot;或者&quot;<code>&lt;p /&gt;</code>&quot;。</p>
<p>可以像实例方法那样去命名、使用<code>asHTML</code>属性。然而，由于<code>asHTML</code>是闭包而不是实例方法，如果你想改变特定元素的 HTML 处理的话，可以用自定义的闭包来取代默认值。</p>
<blockquote>
<p>注意:</p>
<p><code>asHTML</code>声明为<code>lazy</code>属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用<code>asHTML</code>。也就是说，在默认的闭包中可以使用<code>self</code>，因为只有当初始化完成以及<code>self</code>确实存在后，才能访问<code>lazy</code>属性。</p>
<p>注意:<br><code>asHTML</code>声明为<code>lazy</code>属性，因为只有当元素确实需要处理为HTML输出的字符串时，才需要使用<code>asHTML</code>。也就是说，在默认的闭包中可以使用<code>self</code>，因为只有当初始化完成以及<code>self</code>确实存在后，才能访问<code>lazy</code>属性。</p>
</blockquote>
<p><code>HTMLElement</code>类只提供一个构造函数，通过<code>name</code>和<code>text</code>（如果有的话）参数来初始化一个元素。该类也定义了一个析构函数，当<code>HTMLElement</code>实例被销毁时，打印一条消息。</p>
<p>下面的代码展示了如何用<code>HTMLElement</code>类创建实例并打印消息。</p>
<pre><code>var paragraph: HTMLElement? = HTMLElement(name: &quot;p&quot;, text: &quot;hello, world&quot;)
<pre><code class="lang-swift">var paragraph: HTMLElement? = HTMLElement(name: &quot;p&quot;, text: &quot;hello, world&quot;)
println(paragraph!.asHTML())
// prints&quot;hello, world&quot;
</code></pre><blockquote>
<p>注意:</p>
<p>上面的<code>paragraph</code>变量定义为<code>可选HTMLElement</code>，因此我们可以赋值<code>nil</code>给它来演示循环强引用。</p>
</code></pre>
<blockquote>
<p>注意:<br>上面的<code>paragraph</code>变量定义为<code>可选HTMLElement</code>，因此我们可以赋值<code>nil</code>给它来演示循环强引用。</p>
</blockquote>
<p>不幸的是，上面写的<code>HTMLElement</code>类产生了类实例和<code>asHTML</code>默认值的闭包之间的循环强引用。循环强引用如下图所示：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle01_2x.png" alt=""></p>
<p>实例的<code>asHTML</code>属性持有闭包的强引用。但是，闭包在其闭包体内使用了<code>self</code>（引用了<code>self.name</code>和<code>self.text</code>），因此闭包捕获了<code>self</code>，这意味着闭包又反过来持有了<code>HTMLElement</code>实例的强引用。这样两个对象就产生了循环强引用。（更多关于闭包捕获值的信息，请参考<a href="07_Closures.html">值捕获</a>）。</p>
<blockquote>
<p>注意:</p>
<p>虽然闭包多次使用了<code>self</code>，它只捕获<code>HTMLElement</code>实例的一个强引用。</p>
<p>注意:<br>虽然闭包多次使用了<code>self</code>，它只捕获<code>HTMLElement</code>实例的一个强引用。</p>
</blockquote>
<p>如果设置<code>paragraph</code>变量为<code>nil</code>，打破它持有的<code>HTMLElement</code>实例的强引用，<code>HTMLElement</code>实例和它的闭包都不会被销毁，也是因为循环强引用：</p>
<pre><code>paragraph = nil
</code></pre><p>注意<code>HTMLElementdeinitializer</code>中的消息并没有别打印，证明了<code>HTMLElement</code>实例并没有被销毁。</p>
<pre><code class="lang-swift">paragraph = nil
</code></pre>
<p>注意<code>HTMLElementdeinitializer</code>中的消息并没有别打印，证明了<code>HTMLElement</code>实例并没有被销毁。</p>
<p><a name="resolving_strong_reference_cycles_for_closures"></a></p>
<h2 id="-">解决闭包引起的循环强引用</h2>
<p>在定义闭包时同时定义捕获列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。</p>
<blockquote>
<p>注意:</p>
<p>Swift 有如下要求：只要在闭包内使用<code>self</code>的成员，就要用<code>self.someProperty</code>或者<code>self.someMethod</code>（而不只是<code>someProperty</code>或<code>someMethod</code>）。这提醒你可能会不小心就捕获了<code>self</code>。</p>
<p>注意:<br>Swift 有如下要求：只要在闭包内使用<code>self</code>的成员，就要用<code>self.someProperty</code>或者<code>self.someMethod</code>（而不只是<code>someProperty</code>或<code>someMethod</code>）。这提醒你可能会不小心就捕获了<code>self</code>。</p>
</blockquote>
<h3 id="-">定义捕获列表</h3>
<p>捕获列表中的每个元素都是由<code>weak</code>或者<code>unowned</code>关键字和实例的引用（如<code>self</code>或<code>someInstance</code>）成对组成。每一对都在方括号中，通过逗号分开。</p>
<p>捕获列表放置在闭包参数列表和返回类型之前：</p>
<pre><code>@lazy var someClosure: (Int, String) -&gt; String = {
<pre><code class="lang-swift">@lazy var someClosure: (Int, String) -&gt; String = {
[unowned self] (index: Int, stringToProcess: String) -&gt; String in
// closure body goes here
}
</code></pre><p>如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字<code>in</code>：</p>
<pre><code>@lazy var someClosure: () -&gt; String = {
</code></pre>
<p>如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字<code>in</code>：</p>
<pre><code class="lang-swift">@lazy var someClosure: () -&gt; String = {
[unowned self] in
// closure body goes here
}
</code></pre><h3 id="-">弱引用和无主引用</h3>
</code></pre>
<h3 id="-">弱引用和无主引用</h3>
<p>当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。</p>
<p>相反的，当捕获引用有时可能会是<code>nil</code>时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为<code>nil</code>。这使我们可以在闭包内检查它们是否存在。</p>
<blockquote>
<p>注意:</p>
<p>如果捕获的引用绝对不会置为<code>nil</code>，应该用无主引用，而不是弱引用。</p>
<p>注意:<br>如果捕获的引用绝对不会置为<code>nil</code>，应该用无主引用，而不是弱引用。</p>
</blockquote>
<p>前面的<code>HTMLElement</code>例子中，无主引用是正确的解决循环强引用的方法。这样编写<code>HTMLElement</code>类来避免循环强引用：</p>
<pre><code>class HTMLElement {
<pre><code class="lang-swift">class HTMLElement {
let name: String
let text: String?
@ -930,17 +944,20 @@ println(paragraph!.asHTML())
}
}
</code></pre><p>上面的<code>HTMLElement</code>实现和之前的实现一致，只是在<code>asHTML</code>闭包中多了一个捕获列表。这里，捕获列表是<code>[unowned self]</code>，表示“用无主引用而不是强引用来捕获<code>self</code>”。</p>
</code></pre>
<p>上面的<code>HTMLElement</code>实现和之前的实现一致，只是在<code>asHTML</code>闭包中多了一个捕获列表。这里，捕获列表是<code>[unowned self]</code>，表示“用无主引用而不是强引用来捕获<code>self</code>”。</p>
<p>和之前一样，我们可以创建并打印<code>HTMLElement</code>实例：</p>
<pre><code>var paragraph: HTMLElement? = HTMLElement(name: &quot;p&quot;, text: &quot;hello, world&quot;)
<pre><code class="lang-swift">var paragraph: HTMLElement? = HTMLElement(name: &quot;p&quot;, text: &quot;hello, world&quot;)
println(paragraph!.asHTML())
// prints &quot;&lt;p&gt;hello, world&lt;/p&gt;&quot;
</code></pre><p>使用捕获列表后引用关系如下图所示：</p>
</code></pre>
<p>使用捕获列表后引用关系如下图所示：</p>
<p><img src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/closureReferenceCycle02_2x.png" alt=""></p>
<p>这一次，闭包以无主引用的形式捕获<code>self</code>，并不会持有<code>HTMLElement</code>实例的强引用。如果将<code>paragraph</code>赋值为<code>nil</code>，<code>HTMLElement</code>实例将会被销毁，并能看到它的析构函数打印出的消息。</p>
<pre><code>paragraph = nil
<pre><code class="lang-swift">paragraph = nil
// prints &quot;p is being deinitialized&quot;
</code></pre>
</section>

115
chapter2/17_Optional_Chaining.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.17" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.17" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_66">
<section class="normal" id="section-gitbook_542">
<blockquote>
<p>翻译：Jasonbroker</p>
<p>校对：numbbbbb</p>
<p>翻译：Jasonbroker<br>校对：numbbbbb, stanzhai </p>
</blockquote>
<h1 id="optional-chaining">Optional Chaining</h1>
<hr>
@ -607,8 +606,7 @@
</ul>
<p>可选链（Optional Chaining）是一种可以请求和调用属性、方法及子脚本的过程，它的可选性体现于请求或调用的目标当前可能为空（<code>nil</code>）。如果可选的目标有值，那么调用就会成功；相反，如果选择的目标为空（<code>nil</code>），则这种调用将返回空（<code>nil</code>）。多次请求或调用可以被链接在一起形成一个链，如果任何一个节点为空（<code>nil</code>）将导致整个链失效。</p>
<blockquote>
<p>注意：
Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。</p>
<p>注意：<br>Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift 可以使用在任意类型中，并且失败与否可以被检测到。</p>
</blockquote>
<p><a name="optional_chaining_as_an_alternative_to_forced_unwrapping"></a></p>
<h2 id="-">可选链可替代强制解析</h2>
@ -617,49 +615,56 @@ Swift 的可选链和 Objective-C 中的消息为空有些相像，但是 Swift
<p>调用可选链的返回结果与原本的返回结果具有相同的类型，但是原本的返回结果被包装成了一个可选值，当可选链调用成功时，一个应该返回<code>Int</code>的属性将会返回<code>Int?</code>。</p>
<p>下面几段代码将解释可选链和强制解析的不同。</p>
<p>首先定义两个类<code>Person</code>和<code>Residence</code>。</p>
<pre><code>class Person {
<pre><code class="lang-swift">class Person {
var residence: Residence?
}
class Residence {
var numberOfRooms = 1
}
</code></pre><p><code>Residence</code>具有一个<code>Int</code>类型的<code>numberOfRooms</code>，其值为 1。<code>Person</code>具有一个可选<code>residence</code>属性，它的类型是<code>Residence？</code>。</p>
</code></pre>
<p><code>Residence</code>具有一个<code>Int</code>类型的<code>numberOfRooms</code>，其值为 1。<code>Person</code>具有一个可选<code>residence</code>属性，它的类型是<code>Residence？</code>。</p>
<p>如果你创建一个新的<code>Person</code>实例，它的<code>residence</code>属性由于是被定义为可选型的，此属性将默认初始化为空：</p>
<pre><code>let john = Person()
</code></pre><p>如果你想使用感叹号（<code>!</code>）强制解析获得这个人<code>residence</code>属性<code>numberOfRooms</code>属性值，将会引发运行时错误，因为这时没有可以供解析的<code>residence</code>值。</p>
<pre><code>let roomCount = john.residence!.numberOfRooms
<pre><code class="lang-swift">let john = Person()
</code></pre>
<p>如果你想使用感叹号（<code>!</code>）强制解析获得这个人<code>residence</code>属性<code>numberOfRooms</code>属性值，将会引发运行时错误，因为这时没有可以供解析的<code>residence</code>值。</p>
<pre><code class="lang-swift">let roomCount = john.residence!.numberOfRooms
//将导致运行时错误
</code></pre><p>当<code>john.residence</code>不是<code>nil</code>时，会运行通过，且会将<code>roomCount</code> 设置为一个<code>int</code>类型的合理值。然而，如上所述，当<code>residence</code>为空时，这个代码将会导致运行时错误。</p>
</code></pre>
<p>当<code>john.residence</code>不是<code>nil</code>时，会运行通过，且会将<code>roomCount</code> 设置为一个<code>int</code>类型的合理值。然而，如上所述，当<code>residence</code>为空时，这个代码将会导致运行时错误。</p>
<p>可选链提供了一种另一种获得<code>numberOfRooms</code>的方法。利用可选链，使用问号来代替原来<code>!</code>的位置：</p>
<pre><code>if let roomCount = john.residence?.numberOfRooms {
<pre><code class="lang-swift">if let roomCount = john.residence?.numberOfRooms {
println(&quot;John&#39;s residence has \(roomCount) room(s).&quot;)
} else {
println(&quot;Unable to retrieve the number of rooms.&quot;)
}
// 打印 &quot;Unable to retrieve the number of rooms.
</code></pre><p>这告诉 Swift 来链接可选<code>residence?</code>属性，如果<code>residence</code>存在则取回<code>numberOfRooms</code>的值。</p>
</code></pre>
<p>这告诉 Swift 来链接可选<code>residence?</code>属性，如果<code>residence</code>存在则取回<code>numberOfRooms</code>的值。</p>
<p>因为这种尝试获得<code>numberOfRooms</code>的操作有可能失败，可选链会返回<code>Int?</code>类型值，或者称作“可选<code>Int</code>”。当<code>residence</code>是空的时候（上例），选择<code>Int</code>将会为空，因此会出先无法访问<code>numberOfRooms</code>的情况。</p>
<p>要注意的是，即使numberOfRooms是非可选<code>Int</code>（<code>Int?</code>）时这一点也成立。只要是通过可选链的请求就意味着最后<code>numberOfRooms</code>总是返回一个<code>Int?</code>而不是<code>Int</code>。</p>
<p>你可以自己定义一个<code>Residence</code>实例给<code>john.residence</code>，这样它就不再为空了：</p>
<pre><code>john.residence = Residence()
</code></pre><p><code>john.residence</code> 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得<code>numberOfRoooms</code>，它将返回一个包含默认值 1 的<code>Int?</code>：</p>
<pre><code>if let roomCount = john.residence?.numberOfRooms {
<pre><code class="lang-swift">john.residence = Residence()
</code></pre>
<p><code>john.residence</code> 现在有了实际存在的实例而不是nil了。如果你想使用和前面一样的可选链来获得<code>numberOfRoooms</code>，它将返回一个包含默认值 1 的<code>Int?</code>：</p>
<pre><code class="lang-swift">if let roomCount = john.residence?.numberOfRooms {
println(&quot;John&#39;s residence has \(roomCount) room(s).&quot;)
} else {
println(&quot;Unable to retrieve the number of rooms.&quot;)
}
// 打印 &quot;John&#39;s residence has 1 room(s)&quot;。
</code></pre><p><a name="defining_model_classes_for_optional_chaining"></a></p>
</code></pre>
<p><a name="defining_model_classes_for_optional_chaining"></a></p>
<h2 id="-">为可选链定义模型类</h2>
<p>你可以使用可选链来多层调用属性，方法，和子脚本。这让你可以利用它们之间的复杂模型来获取更底层的属性，并检查是否可以成功获取此类底层属性。</p>
<p>后面的代码定义了四个将在后面使用的模型类，其中包括多层可选链。这些类是由上面的<code>Person</code>和<code>Residence</code>模型通过添加一个<code>Room</code>和一个<code>Address</code>类拓展来。</p>
<p><code>Person</code>类定义与之前相同。</p>
<pre><code>class Person {
<pre><code class="lang-swift">class Person {
var residence: Residence?
}
</code></pre><p><code>Residence</code>类比之前复杂些。这次，它定义了一个变量 <code>rooms</code>，它被初始化为一个<code>Room[]</code>类型的空数组：</p>
<pre><code>class Residence {
</code></pre>
<p><code>Residence</code>类比之前复杂些。这次，它定义了一个变量 <code>rooms</code>，它被初始化为一个<code>Room[]</code>类型的空数组：</p>
<pre><code class="lang-swift">class Residence {
var rooms = Room[]()
var numberOfRooms: Int {
return rooms.count
@ -672,17 +677,19 @@ class Residence {
}
var address: Address?
}
</code></pre><p>因为<code>Residence</code>存储了一个<code>Room</code>实例的数组，它的<code>numberOfRooms</code>属性值不是一个固定的存储值，而是通过计算而来的。<code>numberOfRooms</code>属性值是由返回<code>rooms</code>数组的<code>count</code>属性值得到的。</p>
</code></pre>
<p>因为<code>Residence</code>存储了一个<code>Room</code>实例的数组，它的<code>numberOfRooms</code>属性值不是一个固定的存储值，而是通过计算而来的。<code>numberOfRooms</code>属性值是由返回<code>rooms</code>数组的<code>count</code>属性值得到的。</p>
<p>为了能快速访问<code>rooms</code>数组，<code>Residence</code>定义了一个只读的子脚本，通过插入数组的元素角标就可以成功调用。如果该角标存在，子脚本则将该元素返回。</p>
<p><code>Residence</code>中也提供了一个<code>printNumberOfRooms</code>的方法，即简单的打印房间个数。</p>
<p>最后，<code>Residence</code>定义了一个可选属性叫<code>address</code>（<code>address?</code>）。<code>Address</code>类的属性将在后面定义。
用于<code>rooms</code>数组的<code>Room</code>类是一个很简单的类，它只有一个<code>name</code>属性和一个设定<code>room</code>名的初始化器。</p>
<pre><code>class Room {
<pre><code class="lang-swift">class Room {
let name: String
init(name: String) { self.name = name }
}
</code></pre><p>这个模型中的最终类叫做<code>Address</code>。它有三个类型是<code>String?</code>的可选属性。前面两个可选属性<code>buildingName</code>和 <code>buildingNumber</code>作为地址的一部分，是定义某个建筑物的两种方式。第三个属性<code>street</code>，用于命名地址的街道名：</p>
<pre><code>class Address {
</code></pre>
<p>这个模型中的最终类叫做<code>Address</code>。它有三个类型是<code>String?</code>的可选属性。前面两个可选属性<code>buildingName</code>和 <code>buildingNumber</code>作为地址的一部分，是定义某个建筑物的两种方式。第三个属性<code>street</code>，用于命名地址的街道名：</p>
<pre><code class="lang-swift">class Address {
var buildingName: String?
var buildingNumber: String?
var street: String?
@ -696,51 +703,55 @@ class Residence {
}
}
}
</code></pre><p><code>Address</code>类还提供了一个<code>buildingIdentifier</code>的方法，它的返回值类型为<code>String?</code>。这个方法检查<code>buildingName</code>和<code>buildingNumber</code>的属性，如果<code>buildingName</code>有值则将其返回，或者如果<code>buildingNumber</code>有值则将其返回，再或如果没有一个属性有值，返回空。</p>
</code></pre>
<p><code>Address</code>类还提供了一个<code>buildingIdentifier</code>的方法，它的返回值类型为<code>String?</code>。这个方法检查<code>buildingName</code>和<code>buildingNumber</code>的属性，如果<code>buildingName</code>有值则将其返回，或者如果<code>buildingNumber</code>有值则将其返回，再或如果没有一个属性有值，返回空。</p>
<p><a name="calling_properties_through_optional_chaining"></a></p>
<h2 id="-">通过可选链调用属性</h2>
<p>正如上面“ <a href="#optional_chaining_as_an_alternative_to_forced_unwrapping">可选链可替代强制解析</a>”中所述，你可以利用可选链的可选值获取属性，并且检查属性是否获取成功。然而，你不能使用可选链为属性赋值。</p>
<p>使用上述定义的类来创建一个人实例，并再次尝试后去它的<code>numberOfRooms</code>属性：</p>
<pre><code>let john = Person()
<pre><code class="lang-swift">let john = Person()
if let roomCount = john.residence?.numberOfRooms {
println(&quot;John&#39;s residence has \(roomCount) room(s).&quot;)
} else {
println(&quot;Unable to retrieve the number of rooms.&quot;)
}
// 打印 &quot;Unable to retrieve the number of rooms。
</code></pre><p>由于<code>john.residence</code>是空，所以这个可选链和之前一样失败了，但是没有运行时错误。</p>
</code></pre>
<p>由于<code>john.residence</code>是空，所以这个可选链和之前一样失败了，但是没有运行时错误。</p>
<p><a name="calling_methods_through_optional_chaining"></a></p>
<h2 id="-">通过可选链调用方法</h2>
<p>你可以使用可选链的来调用可选值的方法并检查方法调用是否成功。即使这个方法没有返回值，你依然可以使用可选链来达成这一目的。</p>
<p><code>Residence</code>的<code>printNumberOfRooms</code>方法会打印<code>numberOfRooms</code>的当前值。方法如下：</p>
<pre><code>func printNumberOfRooms(){
<pre><code class="lang-swift">func printNumberOfRooms(){
println(“The number of rooms is \(numberOfRooms)”)
}
</code></pre><p>这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型<code>Void</code>（参见Function Without Return Values）。</p>
</code></pre>
<p>这个方法没有返回值。但是，没有返回值类型的函数和方法有一个隐式的返回值类型<code>Void</code>（参见Function Without Return Values）。</p>
<p>如果你利用可选链调用此方法，这个方法的返回值类型将是<code>Void?</code>，而不是<code>Void</code>，因为当通过可选链调用方法时返回值总是可选类型（optional type）。即使这个方法本身没有定义返回值，你也可以使用<code>if</code>语句来检查是否能成功调用<code>printNumberOfRooms</code>方法：如果方法通过可选链调用成功，<code>printNumberOfRooms</code>的隐式返回值将会是<code>Void</code>，如果没有成功，将返回<code>nil</code>：</p>
<pre><code>if john.residence?.printNumberOfRooms() {
<pre><code class="lang-swift">if john.residence?.printNumberOfRooms() {
println(&quot;It was possible to print the number of rooms.&quot;)
} else {
println(&quot;It was not possible to print the number of rooms.&quot;)
}
// 打印 &quot;It was not possible to print the number of rooms.&quot;。
</code></pre><p><a name="calling_subscripts_through_optional_chaining"></a></p>
</code></pre>
<p><a name="calling_subscripts_through_optional_chaining"></a></p>
<h2 id="-">使用可选链调用子脚本</h2>
<p>你可以使用可选链来尝试从子脚本获取值并检查子脚本的调用是否成功，然而，你不能通过可选链来设置子代码。</p>
<blockquote>
<p>注意：
当你使用可选链来获取子脚本的时候，你应该将问号放在子脚本括号的前面而不是后面。可选链的问号一般直接跟在表达语句的后面。</p>
<p>注意：<br>当你使用可选链来获取子脚本的时候，你应该将问号放在子脚本括号的前面而不是后面。可选链的问号一般直接跟在表达语句的后面。</p>
</blockquote>
<p>下面这个例子用在<code>Residence</code>类中定义的子脚本来获取<code>john.residence</code>数组中第一个房间的名字。因为<code>john.residence</code>现在是<code>nil</code>，子脚本的调用失败了。</p>
<pre><code>if let firstRoomName = john.residence?[0].name {
<pre><code class="lang-swift">if let firstRoomName = john.residence?[0].name {
println(&quot;The first room name is \(firstRoomName).&quot;)
} else {
println(&quot;Unable to retrieve the first room name.&quot;)
}
// 打印 &quot;Unable to retrieve the first room name.&quot;。
</code></pre><p>在子代码调用中可选链的问号直接跟在<code>john.residence</code>的后面，在子脚本括号的前面，因为<code>john.residence</code>是可选链试图获得的可选值。</p>
</code></pre>
<p>在子代码调用中可选链的问号直接跟在<code>john.residence</code>的后面，在子脚本括号的前面，因为<code>john.residence</code>是可选链试图获得的可选值。</p>
<p>如果你创建一个<code>Residence</code>实例给<code>john.residence</code>，且在他的<code>rooms</code>数组中有一个或多个<code>Room</code>实例，那么你可以使用可选链通过<code>Residence</code>子脚本来获取在<code>rooms</code>数组中的实例了：</p>
<pre><code>let johnsHouse = Residence()
<pre><code class="lang-swift">let johnsHouse = Residence()
johnsHouse.rooms += Room(name: &quot;Living Room&quot;)
johnsHouse.rooms += Room(name: &quot;Kitchen&quot;)
john.residence = johnsHouse
@ -751,7 +762,8 @@ if let firstRoomName = john.residence?[0].name {
println(&quot;Unable to retrieve the first room name.&quot;)
}
// 打印 &quot;The first room name is Living Room.&quot;。
</code></pre><p><a name="linking_multiple_levels_of_chaining"></a></p>
</code></pre>
<p><a name="linking_multiple_levels_of_chaining"></a></p>
<h2 id="-">连接多层链接</h2>
<p>你可以将多层可选链连接在一起，可以掘取模型内更下层的属性方法和子脚本。然而多层可选链不能再添加比已经返回的可选值更多的层。
也就是说：</p>
@ -761,43 +773,46 @@ if let firstRoomName = john.residence?[0].name {
<p>如果你试图通过可选链获得<code>Int</code>值，不论使用了多少层链接返回的总是<code>Int?</code>。
相似的，如果你试图通过可选链获得<code>Int?</code>值，不论使用了多少层链接返回的总是<code>Int?</code>。</p>
<p>下面的例子试图获取<code>john</code>的<code>residence</code>属性里的<code>address</code>的<code>street</code>属性。这里使用了两层可选链来联系<code>residence</code>和<code>address</code>属性，它们两者都是可选类型：</p>
<pre><code>if let johnsStreet = john.residence?.address?.street {
<pre><code class="lang-swift">if let johnsStreet = john.residence?.address?.street {
println(&quot;John&#39;s street name is \(johnsStreet).&quot;)
} else {
println(&quot;Unable to retrieve the address.&quot;)
}
// 打印 &quot;Unable to retrieve the address.”。
</code></pre><p><code>john.residence</code>的值现在包含一个<code>Residence</code>实例，然而<code>john.residence.address</code>现在是<code>nil</code>，因此<code>john.residence?.address?.street</code>调用失败。</p>
</code></pre>
<p><code>john.residence</code>的值现在包含一个<code>Residence</code>实例，然而<code>john.residence.address</code>现在是<code>nil</code>，因此<code>john.residence?.address?.street</code>调用失败。</p>
<p>从上面的例子发现，你试图获得<code>street</code>属性值。这个属性的类型是<code>String?</code>。因此尽管在可选类型属性前使用了两层可选链，<code>john.residence?.address?.street</code>的返回值类型也是<code>String?</code>。</p>
<p>如果你为<code>Address</code>设定一个实例来作为<code>john.residence.address</code>的值，并为<code>address</code>的<code>street</code>属性设定一个实际值，你可以通过多层可选链来得到这个属性值。</p>
<pre><code>let johnsAddress = Address()
<pre><code class="lang-swift">let johnsAddress = Address()
johnsAddress.buildingName = &quot;The Larches&quot;
johnsAddress.street = &quot;Laurel Street&quot;
john.residence!.address = johnsAddress
if let johnsStreet = john.residence?.address?.street {
</code></pre>
<pre><code class="lang-swift">if let johnsStreet = john.residence?.address?.street {
println(&quot;John&#39;s street name is \(johnsStreet).&quot;)
} else {
println(&quot;Unable to retrieve the address.&quot;)
}
// 打印 &quot;John&#39;s street name is Laurel Street.&quot;。
</code></pre><p>值得注意的是，“<code>!</code>”符号在给<code>john.residence.address</code>分配<code>address</code>实例时的使用。<code>john.residence</code>属性是一个可选类型，因此你需要在它获取<code>address</code>属性之前使用<code>!</code>解析以获得它的实际值。</p>
</code></pre>
<p>值得注意的是，“<code>!</code>”符号在给<code>john.residence.address</code>分配<code>address</code>实例时的使用。<code>john.residence</code>属性是一个可选类型，因此你需要在它获取<code>address</code>属性之前使用<code>!</code>解析以获得它的实际值。</p>
<p><a name="chaining_on_methods_with_optional_return_values"></a></p>
<h2 id="-">链接可选返回值的方法</h2>
<p>前面的例子解释了如何通过可选链来获得可选类型属性值。你也可以通过可选链调用一个返回可选类型值的方法并按需链接该方法的返回值。</p>
<p>下面的例子通过可选链调用了<code>Address</code>类中的<code>buildingIdentifier</code> 方法。这个方法的返回值类型是<code>String?</code>。如上所述，这个方法在可选链调用后最终的返回值类型依然是<code>String?</code>：</p>
<pre><code>if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
<pre><code class="lang-swift">if let buildingIdentifier = john.residence?.address?.buildingIdentifier() {
println(&quot;John&#39;s building identifier is \(buildingIdentifier).&quot;)
}
// 打印 &quot;John&#39;s building identifier is The Larches.&quot;。
</code></pre><p>如果你还想进一步对方法返回值执行可选链，将可选链问号符放在方法括号的后面：</p>
<pre><code>if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
</code></pre>
<p>如果你还想进一步对方法返回值执行可选链，将可选链问号符放在方法括号的后面：</p>
<pre><code class="lang-swift">if let upper = john.residence?.address?.buildingIdentifier()?.uppercaseString {
println(&quot;John&#39;s uppercase building identifier is \(upper).&quot;)
}
// 打印 &quot;John&#39;s uppercase building identifier is THE LARCHES.&quot;。
</code></pre><blockquote>
<p>注意：
在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是<code>buildingIdentifier</code>方法的返回值，不是<code>buildingIdentifier</code>方法本身。</p>
</code></pre>
<blockquote>
<p>注意：<br>在上面的例子中，你将可选链问号符放在括号后面是因为你想要链接的可选值是<code>buildingIdentifier</code>方法的返回值，不是<code>buildingIdentifier</code>方法本身。</p>
</blockquote>

140
chapter2/18_Type_Casting.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.18" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.18" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,36 +587,36 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_68">
<section class="normal" id="section-gitbook_544">
<blockquote>
<p>翻译：xiehurricane</p>
<p>校对：happyming</p>
<p>翻译：xiehurricane<br>校对：happyming </p>
</blockquote>
<h1 id="-type-casting-">类型转换（Type Casting）</h1>
<h1 id="-type-casting-">类型检查（Type Casting）</h1>
<hr>
<p>本页包含内容：</p>
<ul>
<li><a href="#defining_a_class_hierarchy_for_type_casting">定义一个类层次作为例子</a></li>
<li><a href="#checking_type">检查类型</a></li>
<li><a href="#downcasting">向下转型（Downcasting）</a></li>
<li><a href="#type_casting_for_any_and_anyobject"><code>Any</code>和<code>AnyObject</code>的类型转换</a></li>
<li><a href="#type_casting_for_any_and_anyobject"><code>Any</code>和<code>AnyObject</code>的类型检查</a></li>
</ul>
<p> <em>类型检查</em>是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。</p>
<p> 类型检查在 Swift 中使用<code>is</code> 和 <code>as</code>操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。</p>
<p> 你也可以用来检查一个类是否实现了某个协议，就像在 <a href="Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363">Checking for Protocol Conformance</a>部分讲述的一样。</p>
<p><em>类型检查</em>是一种检查类实例的方式，并且或者也是让实例作为它的父类或者子类的一种方式。</p>
<p>类型检查在 Swift 中使用<code>is</code> 和 <code>as</code>操作符实现。这两个操作符提供了一种简单达意的方式去检查值的类型或者转换它的类型。</p>
<p>你也可以用来检查一个类是否实现了某个协议，就像在 <a href="Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-XID_363">Checking for Protocol Conformance</a>部分讲述的一样。</p>
<p><a name="defining_a_class_hierarchy_for_type_casting"></a></p>
<h2 id="-">定义一个类层次作为例子</h2>
<p> 你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。</p>
<p> 第一个代码片段定义了一个新的基础类<code>MediaItem</code>。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 <code>String</code> 类型的 <code>name</code> 属性，和一个<code>init name</code>初始化器。（它假定所有的媒体项都有个名称。）</p>
<pre><code>class MediaItem {
<p>你可以将它用在类和子类的层次结构上，检查特定类实例的类型并且转换这个类实例的类型成为这个层次结构中的其他类型。这下面的三个代码段定义了一个类层次和一个包含了几个这些类实例的数组，作为类型检查的例子。</p>
<p>第一个代码片段定义了一个新的基础类<code>MediaItem</code>。这个类为任何出现在数字媒体库的媒体项提供基础功能。特别的，它声明了一个 <code>String</code> 类型的 <code>name</code> 属性，和一个<code>init name</code>初始化器。（它假定所有的媒体项都有个名称。）</p>
<pre><code class="lang-swift">class MediaItem {
var name: String
init(name: String) {
self.name = name
}
}
</code></pre><p> 下一个代码段定义了 <code>MediaItem</code> 的两个子类。第一个子类<code>Movie</code>，在父类（或者说基类）的基础上增加了一个 <code>director</code>（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 <code>artist</code>（艺术家） 属性，和相应的初始化器：</p>
<pre><code>class Movie: MediaItem {
</code></pre>
<p>下一个代码段定义了 <code>MediaItem</code> 的两个子类。第一个子类<code>Movie</code>，在父类（或者说基类）的基础上增加了一个 <code>director</code>（导演） 属性，和相应的初始化器。第二个类在父类的基础上增加了一个 <code>artist</code>（艺术家） 属性，和相应的初始化器：</p>
<pre><code class="lang-swift">class Movie: MediaItem {
var director: String
init(name: String, director: String) {
self.director = director
@ -631,9 +631,9 @@ class Song: MediaItem {
super.init(name: name)
}
}
</code></pre><p> 最后一个代码段创建了一个数组常量 <code>library</code>
，包含两个<code>Movie</code>实例和三个<code>Song</code>实例。<code>library</code>的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出<code>Movie</code> 和 <code>Song</code> 有共同的父类 <code>MediaItem</code> ，所以它推断出 <code>MediaItem[]</code> 类作为 <code>library</code> 的类型。</p>
<pre><code>let library = [
</code></pre>
<p>最后一个代码段创建了一个数组常量 <code>library</code>，包含两个<code>Movie</code>实例和三个<code>Song</code>实例。<code>library</code>的类型是在它被初始化时根据它数组中所包含的内容推断来的。Swift 的类型检测器能够演绎出<code>Movie</code> 和 <code>Song</code> 有共同的父类 <code>MediaItem</code> ，所以它推断出 <code>MediaItem[]</code> 类作为 <code>library</code> 的类型。</p>
<pre><code class="lang-swift">let library = [
Movie(name: &quot;Casablanca&quot;, director: &quot;Michael Curtiz&quot;),
Song(name: &quot;Blue Suede Shoes&quot;, artist: &quot;Elvis Presley&quot;),
Movie(name: &quot;Citizen Kane&quot;, director: &quot;Orson Welles&quot;),
@ -641,12 +641,13 @@ class Song: MediaItem {
Song(name: &quot;Never Gonna Give You Up&quot;, artist: &quot;Rick Astley&quot;)
]
// the type of &quot;library&quot; is inferred to be MediaItem[]
</code></pre><p> 在幕后<code>library</code> 里存储的媒体项依然是 <code>Movie</code> 和 <code>Song</code> 类型的，但是，若你迭代它，取出的实例会是 <code>MediaItem</code> 类型的，而不是 <code>Movie</code> 和 <code>Song</code> 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。</p>
</code></pre>
<p>在幕后<code>library</code> 里存储的媒体项依然是 <code>Movie</code> 和 <code>Song</code> 类型的，但是，若你迭代它，取出的实例会是 <code>MediaItem</code> 类型的，而不是 <code>Movie</code> 和 <code>Song</code> 类型的。为了让它们作为它们本来的类型工作，你需要检查它们的类型或者向下转换它们的类型到其它类型，就像下面描述的一样。</p>
<p><a name="checking_type"></a></p>
<h2 id="-">检查类型</h2>
<p> 用类型检查操作符(<code>is</code>)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
<p> 下面的例子定义了两个变量，<code>movieCount</code> 和 <code>songCount</code>，用来计算数组<code>library</code> 中 <code>Movie</code> 和 <code>Song</code> 类型的实例数量。</p>
<pre><code>var movieCount = 0
<h2 id="-checking-type-">检查类型（Checking Type）</h2>
<p>用类型检查操作符(<code>is</code>)来检查一个实例是否属于特定子类型。若实例属于那个子类型，类型检查操作符返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
<p>下面的例子定义了两个变量，<code>movieCount</code> 和 <code>songCount</code>，用来计算数组<code>library</code> 中 <code>Movie</code> 和 <code>Song</code> 类型的实例数量。</p>
<pre><code class="lang-swift">var movieCount = 0
var songCount = 0
for item in library {
@ -659,20 +660,21 @@ for item in library {
println(&quot;Media library contains \(movieCount) movies and \(songCount) songs&quot;)
// prints &quot;Media library contains 2 movies and 3 songs&quot;
</code></pre><p> 示例迭代了数组 <code>library</code> 中的所有项。每一次， <code>for</code>-<code>in</code> 循环设置
<code>item</code> 为数组中的下一个 <code>MediaItem</code>。</p>
<p> 若当前 <code>MediaItem</code> 是一个 <code>Movie</code> 类型的实例， <code>item is Movie</code> 返回
<code>true</code>，相反返回 <code>false</code>。同样的，<code>item is
Song</code>检查item是否为<code>Song</code>类型的实例。在循环结束后，<code>movieCount</code> 和 <code>songCount</code>的值就是被找到属于各自的类型的实例数量。</p>
</code></pre>
<p>示例迭代了数组 <code>library</code> 中的所有项。每一次， <code>for</code>-<code>in</code> 循环设置
<code>item</code> 为数组中的下一个 <code>MediaItem</code>。</p>
<p>若当前 <code>MediaItem</code> 是一个 <code>Movie</code> 类型的实例， <code>item is Movie</code> 返回
<code>true</code>，相反返回 <code>false</code>。同样的，<code>item is
Song</code>检查item是否为<code>Song</code>类型的实例。在循环结束后，<code>movieCount</code> 和 <code>songCount</code>的值就是被找到属于各自的类型的实例数量。</p>
<p><a name="downcasting"></a></p>
<h2 id="-downcasting-">向下转型（Downcasting）</h2>
<p> 某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型转换操作符(<code>as</code>)</p>
<p> 因为向下转型可能会失败，类型转型操作符带有两种不同形式。可选形式（ optional form） <code>as?</code> 返回一个你试图下转成的类型的可选值（optional value）。强制形式 <code>as</code> 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。</p>
<p> 当你不确定向下转型可以成功时，用类型转换的可选形式(<code>as?</code>)。可选形式的类型转换总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 <code>nil</code> 。这使你能够检查向下转型是否成功。</p>
<p> 只有你可以确定向下转型一定会成功时，才使用强制形式。当你试图向下转型为一个不正确的类型时，强制形式的类型转换会触发一个运行时错误。</p>
<p> 下面的例子，迭代了<code>library</code>里的每一个 <code>MediaItem</code> ，并打印出适当的描述。要这样做，<code>item</code>需要真正作为<code>Movie</code> 或 <code>Song</code>的类型来使用。不仅仅是作为 <code>MediaItem</code>。为了能够使用<code>Movie</code> 或 <code>Song</code>的 <code>director</code> 或 <code>artist</code>属性，这是必要的。</p>
<p> 在这个示例中，数组中的每一个<code>item</code>可能是 <code>Movie</code> 或 <code>Song</code>。 事前你不知道每个<code>item</code>的真实类型，所以这里使用可选形式的类型转换 （<code>as?</code>）去检查循环里的每次下转。</p>
<pre><code>for item in library {
<p>某类型的一个常量或变量可能在幕后实际上属于一个子类。你可以相信，上面就是这种情况。你可以尝试向下转到它的子类型，用类型检查操作符(<code>as</code>)</p>
<p>因为向下转型可能会失败，类型转型操作符带有两种不同形式。可选形式（ optional form） <code>as?</code> 返回一个你试图下转成的类型的可选值（optional value）。强制形式 <code>as</code> 把试图向下转型和强制解包（force-unwraps）结果作为一个混合动作。</p>
<p>当你不确定向下转型可以成功时，用类型检查的可选形式(<code>as?</code>)。可选形式的类型检查总是返回一个可选值（optional value），并且若下转是不可能的，可选值将是 <code>nil</code> 。这使你能够检查向下转型是否成功。</p>
<p>只有你可以确定向下转型一定会成功时，才使用强制形式。当你试图向下转型为一个不正确的类型时，强制形式的类型检查会触发一个运行时错误。</p>
<p>下面的例子，迭代了<code>library</code>里的每一个 <code>MediaItem</code> ，并打印出适当的描述。要这样做，<code>item</code>需要真正作为<code>Movie</code> 或 <code>Song</code>的类型来使用。不仅仅是作为 <code>MediaItem</code>。为了能够使用<code>Movie</code> 或 <code>Song</code>的 <code>director</code> 或 <code>artist</code>属性，这是必要的。</p>
<p>在这个示例中，数组中的每一个<code>item</code>可能是 <code>Movie</code> 或 <code>Song</code>。 事前你不知道每个<code>item</code>的真实类型，所以这里使用可选形式的类型检查 （<code>as?</code>）去检查循环里的每次下转。</p>
<pre><code class="lang-swift">for item in library {
if let movie = item as? Movie {
println(&quot;Movie: &#39;\(movie.name)&#39;, dir. \(movie.director)&quot;)
} else if let song = item as? Song {
@ -685,58 +687,58 @@ println(&quot;Media library contains \(movieCount) movies and \(songCount) songs
// Movie: &#39;Citizen Kane&#39;, dir. Orson Welles
// Song: &#39;The One And Only&#39;, by Chesney Hawkes
// Song: &#39;Never Gonna Give You Up&#39;, by Rick Astley
</code></pre><p> 示例首先试图将 <code>item</code> 下转为 <code>Movie</code>。因为 <code>item</code> 是一个 <code>MediaItem</code>
类型的实例，它可能是一个<code>Movie</code>；同样，它可能是一个 <code>Song</code>，或者仅仅是基类
<code>MediaItem</code>。因为不确定，<code>as?</code>形式在试图下转时将返还一个可选值。 <code>item as Movie</code> 的返回值是<code>Movie?</code>类型或 “optional <code>Movie</code>”。</p>
<p> 当向下转型为 <code>Movie</code> 应用在两个 <code>Song</code>
实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 <code>Movie</code>真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“<code>if let movie = item as? Movie</code>”，可以这样解读：</p>
<p> “尝试将 <code>item</code> 转为 <code>Movie</code>类型。若成功，设置一个新的临时常量 <code>movie</code> 来存储返回的可选<code>Movie</code>”</p>
<p> 若向下转型成功，然后<code>movie</code>的属性将用于打印一个<code>Movie</code>实例的描述，包括它的导演的名字<code>director</code>。当<code>Song</code>被找到时，一个相近的原理被用来检测 <code>Song</code> 实例和打印它的描述。</p>
</code></pre>
<p>示例首先试图将 <code>item</code> 下转为 <code>Movie</code>。因为 <code>item</code> 是一个 <code>MediaItem</code>
类型的实例，它可能是一个<code>Movie</code>；同样，它可能是一个 <code>Song</code>，或者仅仅是基类
<code>MediaItem</code>。因为不确定，<code>as?</code>形式在试图下转时将返还一个可选值。 <code>item as Movie</code> 的返回值是<code>Movie?</code>类型或 “optional <code>Movie</code>”。</p>
<p>当向下转型为 <code>Movie</code> 应用在两个 <code>Song</code>
实例时将会失败。为了处理这种情况，上面的例子使用了可选绑定（optional binding）来检查可选 <code>Movie</code>真的包含一个值（这个是为了判断下转是否成功。）可选绑定是这样写的“<code>if let movie = item as? Movie</code>”，可以这样解读：</p>
<p>“尝试将 <code>item</code> 转为 <code>Movie</code>类型。若成功，设置一个新的临时常量 <code>movie</code> 来存储返回的可选<code>Movie</code>”</p>
<p>若向下转型成功，然后<code>movie</code>的属性将用于打印一个<code>Movie</code>实例的描述，包括它的导演的名字<code>director</code>。当<code>Song</code>被找到时，一个相近的原理被用来检测 <code>Song</code> 实例和打印它的描述。</p>
<blockquote>
<p>注意：</p>
<p>转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。</p>
<p>注意：<br>转换没有真的改变实例或它的值。潜在的根本的实例保持不变；只是简单地把它作为它被转换成的类来使用。</p>
</blockquote>
<p><a name="type_casting_for_any_and_anyobject"></a></p>
<h2 id="-any-anyobject-"><code>Any</code>和<code>AnyObject</code>的类型转换</h2>
<p> Swift为不确定类型提供了两种特殊类型别名：</p>
<h2 id="-any-anyobject-"><code>Any</code>和<code>AnyObject</code>的类型检查</h2>
<p>Swift为不确定类型提供了两种特殊类型别名：</p>
<ul>
<li><p><code>AnyObject</code>可以代表任何class类型的实例。</p>
</li>
<li><p><code>Any</code>可以表示任何类型，除了方法类型（function types）。</p>
</li>
<li><code>AnyObject</code>可以代表任何class类型的实例。</li>
<li><code>Any</code>可以表示任何类型，除了方法类型（function types）。</li>
</ul>
<blockquote>
<p>注意：</p>
<p>只有当你明确的需要它的行为和功能时才使用<code>Any</code>和<code>AnyObject</code>。在你的代码里使用你期望的明确的类型总是更好的。</p>
<p>注意：<br>只有当你明确的需要它的行为和功能时才使用<code>Any</code>和<code>AnyObject</code>。在你的代码里使用你期望的明确的类型总是更好的。</p>
</blockquote>
<h3 id="-anyobject-"><code>AnyObject</code>类型</h3>
<p> 当需要在工作中使用 Cocoa
APIs，它一般接收一个<code>AnyObject[]</code>类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。</p>
<p> 在这些情况下，你可以使用强制形式的类型转换(<code>as</code>)来下转在数组中的每一项到比 <code>AnyObject</code> 更明确的类型，不需要可选解析（optional unwrapping）。</p>
<p> 下面的示例定义了一个 <code>AnyObject[]</code> 类型的数组并填入三个<code>Movie</code>类型的实例：</p>
<pre><code>let someObjects: AnyObject[] = [
<p>当需要在工作中使用 Cocoa
APIs，它一般接收一个<code>AnyObject[]</code>类型的数组，或者说“一个任何对象类型的数组”。这是因为 Objective-C 没有明确的类型化数组。但是，你常常可以确定包含在仅从你知道的 API 信息提供的这样一个数组中的对象的类型。</p>
<p>在这些情况下，你可以使用强制形式的类型检查(<code>as</code>)来下转在数组中的每一项到比 <code>AnyObject</code> 更明确的类型，不需要可选解析（optional unwrapping）。</p>
<p>下面的示例定义了一个 <code>AnyObject[]</code> 类型的数组并填入三个<code>Movie</code>类型的实例：</p>
<pre><code class="lang-swift">let someObjects: AnyObject[] = [
Movie(name: &quot;2001: A Space Odyssey&quot;, director: &quot;Stanley Kubrick&quot;),
Movie(name: &quot;Moon&quot;, director: &quot;Duncan Jones&quot;),
Movie(name: &quot;Alien&quot;, director: &quot;Ridley Scott&quot;)
]
</code></pre><p> 因为知道这个数组只包含 <code>Movie</code> 实例，你可以直接用(<code>as</code>)下转并解包到不可选的<code>Movie</code>类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。</p>
<pre><code>for object in someObjects {
</code></pre>
<p>因为知道这个数组只包含 <code>Movie</code> 实例，你可以直接用(<code>as</code>)下转并解包到不可选的<code>Movie</code>类型（ps：其实就是我们常用的正常类型，这里是为了和可选类型相对比）。</p>
<pre><code class="lang-swift">for object in someObjects {
let movie = object as Movie
println(&quot;Movie: &#39;\(movie.name)&#39;, dir. \(movie.director)&quot;)
}
// Movie: &#39;2001: A Space Odyssey&#39;, dir. Stanley Kubrick
// Movie: &#39;Moon&#39;, dir. Duncan Jones
// Movie: &#39;Alien&#39;, dir. Ridley Scott
</code></pre><p> 为了变为一个更短的形式，下转<code>someObjects</code>数组为<code>Movie[]</code>类型来代替下转每一项方式。</p>
<pre><code>for movie in someObjects as Movie[] {
</code></pre>
<p>为了变为一个更短的形式，下转<code>someObjects</code>数组为<code>Movie[]</code>类型来代替下转每一项方式。</p>
<pre><code class="lang-swift">for movie in someObjects as Movie[] {
println(&quot;Movie: &#39;\(movie.name)&#39;, dir. \(movie.director)&quot;)
}
// Movie: &#39;2001: A Space Odyssey&#39;, dir. Stanley Kubrick
// Movie: &#39;Moon&#39;, dir. Duncan Jones
// Movie: &#39;Alien&#39;, dir. Ridley Scott
</code></pre><h3 id="-any-"><code>Any</code>类型</h3>
<p> 这里有个示例，使用 <code>Any</code> 类型来和混合的不同类型一起工作，包括非<code>class</code>类型。它创建了一个可以存储<code>Any</code>类型的数组 <code>things</code>。</p>
<pre><code>var things = Any[]()
</code></pre>
<h3 id="-any-"><code>Any</code>类型</h3>
<p>这里有个示例，使用 <code>Any</code> 类型来和混合的不同类型一起工作，包括非<code>class</code>类型。它创建了一个可以存储<code>Any</code>类型的数组 <code>things</code>。</p>
<pre><code class="lang-swift">var things = Any[]()
things.append(0)
things.append(0.0)
@ -745,9 +747,10 @@ things.append(3.14159)
things.append(&quot;hello&quot;)
things.append((3.0, 5.0))
things.append(Movie(name: &quot;Ghostbusters&quot;, director: &quot;Ivan Reitman&quot;))
</code></pre><p> <code>things</code> 数组包含两个 <code>Int</code> 值，2个 <code>Double</code> 值，1个 <code>String</code> 值，一个元组 <code>(Double, Double)</code> ，Ivan Reitman 导演的电影“Ghostbusters”。</p>
<p> 你可以在 <code>switch</code> <code>cases</code>里用<code>is</code> 和 <code>as</code> 操作符来发觉只知道是 <code>Any</code> 或 <code>AnyObject</code>的常量或变量的类型。 下面的示例迭代 <code>things</code>数组中的每一项的并用<code>switch</code>语句查找每一项的类型。这几种<code>switch</code>语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：</p>
<pre><code>for thing in things {
</code></pre>
<p><code>things</code> 数组包含两个 <code>Int</code> 值，2个 <code>Double</code> 值，1个 <code>String</code> 值，一个元组 <code>(Double, Double)</code> ，Ivan Reitman 导演的电影“Ghostbusters”。</p>
<p>你可以在 <code>switch</code> <code>cases</code>里用<code>is</code> 和 <code>as</code> 操作符来发觉只知道是 <code>Any</code> 或 <code>AnyObject</code>的常量或变量的类型。 下面的示例迭代 <code>things</code>数组中的每一项的并用<code>switch</code>语句查找每一项的类型。这几种<code>switch</code>语句的情形绑定它们匹配的值到一个规定类型的常量，让它们可以打印它们的值：</p>
<pre><code class="lang-swift">for thing in things {
switch thing {
case 0 as Int:
println(&quot;zero as an Int&quot;)
@ -777,10 +780,9 @@ things.append(Movie(name: &quot;Ghostbusters&quot;, director: &quot;Ivan Reitman
// a string value of &quot;hello&quot;
// an (x, y) point at 3.0, 5.0
// a movie called &#39;Ghostbusters&#39;, dir. Ivan Reitman
</code></pre><p>。</p>
</code></pre>
<blockquote>
<p>注意：</p>
<p>在一个switch语句的case中使用强制形式的类型转换操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。</p>
<p>注意：<br>在一个switch语句的case中使用强制形式的类型检查操作符（as, 而不是 as?）来检查和转换到一个明确的类型。在 switch case 语句的内容中这种检查总是安全的。</p>
</blockquote>

27
chapter2/19_Nested_Types.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.19" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.19" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_70">
<section class="normal" id="section-gitbook_546">
<blockquote>
<p>翻译：Lin-H</p>
<p>校对：shinyzhu</p>
<p>翻译：Lin-H<br>校对：shinyzhu </p>
</blockquote>
<h1 id="-">类型嵌套</h1>
<hr>
@ -606,11 +605,12 @@
<h2 id="-">类型嵌套实例</h2>
<p>下面这个例子定义了一个结构体<code>BlackjackCard</code>(二十一点)，用来模拟<code>BlackjackCard</code>中的扑克牌点数。<code>BlackjackCard</code>结构体包含2个嵌套定义的枚举类型<code>Suit</code> 和 <code>Rank</code>。</p>
<p>在<code>BlackjackCard</code>规则中，<code>Ace</code>牌可以表示1或者11，<code>Ace</code>牌的这一特征用一个嵌套在枚举型<code>Rank</code>的结构体<code>Values</code>来表示。</p>
<pre><code>struct BlackjackCard {
<pre><code class="lang-swift">struct BlackjackCard {
// 嵌套定义枚举型Suit
enum Suit: Character {
case Spades = &quot;♠&quot;, Hearts = &quot;♡&quot;, Diamonds = &quot;♢&quot;, Clubs = &quot;♣&quot;
}
}
// 嵌套定义枚举型Rank
enum Rank: Int {
case Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten
@ -629,6 +629,7 @@
}
}
}
// BlackjackCard 的属性和方法
let rank: Rank, suit: Suit
var description: String {
@ -640,7 +641,8 @@
return output
}
}
</code></pre><p>枚举型的<code>Suit</code>用来描述扑克牌的四种花色，并分别用一个<code>Character</code>类型的值代表花色符号。</p>
</code></pre>
<p>枚举型的<code>Suit</code>用来描述扑克牌的四种花色，并分别用一个<code>Character</code>类型的值代表花色符号。</p>
<p>枚举型的<code>Rank</code>用来描述扑克牌从<code>Ace</code>~10,<code>J</code>,<code>Q</code>,<code>K</code>,13张牌，并分别用一个<code>Int</code>类型的值表示牌的面值。(这个<code>Int</code>类型的值不适用于<code>Ace</code>,<code>J</code>,<code>Q</code>,<code>K</code>的牌)。</p>
<p>如上文所提到的，枚举型<code>Rank</code>在自己内部定义了一个嵌套结构体<code>Values</code>。这个结构体包含两个变量，只有<code>Ace</code>有两个数值，其余牌都只有一个数值。结构体<code>Values</code>中定义的两个属性：</p>
<p><code>first</code>, 为<code>Int</code>
@ -648,16 +650,19 @@
<p><code>Rank</code>定义了一个计算属性<code>values</code>，这个计算属性会根据牌的面值，用适当的数值去初始化<code>Values</code>实例，并赋值给<code>values</code>。对于<code>J</code>,<code>Q</code>,<code>K</code>,<code>Ace</code>会使用特殊数值，对于数字面值的牌使用<code>Int</code>类型的值。</p>
<p><code>BlackjackCard</code>结构体自身有两个属性—<code>rank</code>与<code>suit</code>，也同样定义了一个计算属性<code>description</code>，<code>description</code>属性用<code>rank</code>和<code>suit</code>的中内容来构建对这张扑克牌名字和数值的描述，并用可选类型<code>second</code>来检查是否存在第二个值，若存在，则在原有的描述中增加对第二数值的描述。</p>
<p>因为<code>BlackjackCard</code>是一个没有自定义构造函数的结构体，在<a href="https://github.com/CocoaChina-editors/Welcome-to-Swift/blob/master/The%20Swift%20Programming%20Language/02Language%20Guide/14Initialization.md" target="_blank">Memberwise Initializers for Structure Types</a>中知道结构体有默认的成员构造函数，所以你可以用默认的<code>initializer</code>去初始化新的常量<code>theAceOfSpades</code>:</p>
<pre><code>let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)
<pre><code class="lang-swift">let theAceOfSpades = BlackjackCard(rank: .Ace, suit: .Spades)
println(&quot;theAceOfSpades: \(theAceOfSpades.description)&quot;)
// 打印出 &quot;theAceOfSpades: suit is ♠, value is 1 or 11&quot;
</code></pre><p>尽管<code>Rank</code>和<code>Suit</code>嵌套在<code>BlackjackCard</code>中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中<code>description</code>属性能正确得输出对<code>Ace</code>牌有1和11两个值。</p>
</code></pre>
<p>尽管<code>Rank</code>和<code>Suit</code>嵌套在<code>BlackjackCard</code>中，但仍可被引用，所以在初始化实例时能够通过枚举类型中的成员名称单独引用。在上面的例子中<code>description</code>属性能正确得输出对<code>Ace</code>牌有1和11两个值。</p>
<p><a name="referring_to_nested_types"></a></p>
<h2 id="-">类型嵌套的引用</h2>
<p>在外部对嵌套类型的引用，以被嵌套类型的名字为前缀，加上所要引用的属性名：</p>
<pre><code>let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
<pre><code class="lang-swift">let heartsSymbol = BlackjackCard.Suit.Hearts.toRaw()
// 红心的符号 为 &quot;♡&quot;
</code></pre><p>对于上面这个例子，这样可以使<code>Suit</code>, <code>Rank</code>, 和 <code>Values</code>的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。</p>
</code></pre>
<p>对于上面这个例子，这样可以使<code>Suit</code>, <code>Rank</code>, 和 <code>Values</code>的名字尽可能的短，因为它们的名字会自然的由被定义的上下文来限定。</p>
<p>preview</p>
</section>

102
chapter2/20_Extensions.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.20" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.20" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_72">
<section class="normal" id="section-gitbook_548">
<blockquote>
<p>翻译：lyuka</p>
<p>校对：Hawstein</p>
<p>翻译：lyuka<br>校对：Hawstein </p>
</blockquote>
<h1 id="-extensions-">扩展（Extensions）</h1>
<hr>
@ -615,24 +614,25 @@
<li>使一个已有类型符合某个协议</li>
</ul>
<blockquote>
<p>注意：</p>
<p>如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。</p>
<p>注意：<br>如果你定义了一个扩展向一个已有类型添加新功能，那么这个新功能对该类型的所有已有实例中都是可用的，即使它们是在你的这个扩展的前面定义的。</p>
</blockquote>
<p><a name="extension_syntax"></a></p>
<h2 id="-extension-syntax-">扩展语法（Extension Syntax）</h2>
<p>声明一个扩展使用关键字<code>extension</code>：</p>
<pre><code>extension SomeType {
<pre><code class="lang-swift">extension SomeType {
// 加到SomeType的新功能写到这里
}
</code></pre><p>一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写：</p>
<pre><code>extension SomeType: SomeProtocol, AnotherProctocol {
</code></pre>
<p>一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议（protocol）。当这种情况发生时，协议的名字应该完全按照类或结构体的名字的方式进行书写：</p>
<pre><code class="lang-swift">extension SomeType: SomeProtocol, AnotherProctocol {
// 协议实现写到这里
}
</code></pre><p>按照这种方式添加的协议遵循者（protocol conformance）被称之为<a href="21_Protocols.html#adding_protocol_conformance_with_an_extension">在扩展中添加协议遵循者</a></p>
</code></pre>
<p>按照这种方式添加的协议遵循者（protocol conformance）被称之为<a href="21_Protocols.html#adding_protocol_conformance_with_an_extension">在扩展中添加协议遵循者</a></p>
<p><a name="computed_properties"></a></p>
<h2 id="-computed-properties-">计算型属性（Computed Properties）</h2>
<p>扩展可以向已有类型添加计算型实例属性和计算型类型属性。下面的例子向 Swift 的内建<code>Double</code>类型添加了5个计算型实例属性，从而提供与距离单位协作的基本支持。</p>
<pre><code>extension Double {
<pre><code class="lang-swift">extension Double {
var km: Double { return self * 1_000.0 }
var m : Double { return self }
var cm: Double { return self / 100.0 }
@ -645,27 +645,27 @@ println(&quot;One inch is \(oneInch) meters&quot;)
let threeFeet = 3.ft
println(&quot;Three feet is \(threeFeet) meters&quot;)
// 打印输出：&quot;Three feet is 0.914399970739201 meters&quot;
</code></pre><p>这些计算属性表达的含义是把一个<code>Double</code>型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。</p>
</code></pre>
<p>这些计算属性表达的含义是把一个<code>Double</code>型的值看作是某单位下的长度值。即使它们被实现为计算型属性，但这些属性仍可以接一个带有dot语法的浮点型字面值，而这恰恰是使用这些浮点型字面量实现距离转换的方式。</p>
<p>在上述例子中，一个<code>Double</code>型的值<code>1.0</code>被用来表示“1米”。这就是为什么<code>m</code>计算型属性返回<code>self</code>——表达式<code>1.m</code>被认为是计算<code>1.0</code>的<code>Double</code>值。</p>
<p>其它单位则需要一些转换来表示在米下测量的值。1千米等于1,000米，所以<code>km</code>计算型属性要把值乘以<code>1_000.00</code>来转化成单位米下的数值。类似地，1米有3.28024英尺，所以<code>ft</code>计算型属性要把对应的<code>Double</code>值除以<code>3.28024</code>来实现英尺到米的单位换算。</p>
<p>这些属性是只读的计算型属性，所有从简考虑它们不用<code>get</code>关键字表示。它们的返回值是<code>Double</code>型，而且可以用于所有接受<code>Double</code>的数学计算中：</p>
<pre><code>let aMarathon = 42.km + 195.m
<pre><code class="lang-swift">let aMarathon = 42.km + 195.m
println(&quot;A marathon is \(aMarathon) meters long&quot;)
// 打印输出：&quot;A marathon is 42495.0 meters long&quot;
</code></pre><blockquote>
<p>注意：</p>
<p>扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。</p>
</code></pre>
<blockquote>
<p>注意：<br>扩展可以添加新的计算属性，但是不可以添加存储属性，也不可以向已有属性添加属性观测器(property observers)。</p>
</blockquote>
<p><a name="initializers"></a></p>
<h2 id="-initializers-">构造器（Initializers）</h2>
<p>扩展可以向已有类型添加新的构造器。这可以让你扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项。 </p>
<p>扩展能向类中添加新的便利构造器，但是它们不能向类中添加新的指定构造器或析构函数。指定构造器和析构函数必须总是由原始的类实现来提供。</p>
<blockquote>
<p>注意：</p>
<p>如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。<br>正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。</p>
<p>注意：<br>如果你使用扩展向一个值类型添加一个构造器，该构造器向所有的存储属性提供默认值，而且没有定义任何定制构造器（custom initializers），那么对于来自你的扩展构造器中的值类型，你可以调用默认构造器(default initializers)和逐一成员构造器(memberwise initializers)。<br>正如在值类型的构造器授权中描述的，如果你已经把构造器写成值类型原始实现的一部分，上述规则不再适用。</p>
</blockquote>
<p>下面的例子定义了一个用于描述几何矩形的定制结构体<code>Rect</code>。这个例子同时定义了两个辅助结构体<code>Size</code>和<code>Point</code>，它们都把<code>0.0</code>作为所有属性的默认值：</p>
<pre><code>struct Size {
<pre><code class="lang-swift">struct Size {
var width = 0.0, height = 0.0
}
struct Point {
@ -675,56 +675,62 @@ struct Rect {
var origin = Point()
var size = Size()
}
</code></pre><p>因为结构体<code>Rect</code>提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的<code>Rect</code>实例：</p>
<pre><code>let defaultRect = Rect()
</code></pre>
<p>因为结构体<code>Rect</code>提供了其所有属性的默认值，所以正如默认构造器中描述的，它可以自动接受一个默认的构造器和一个成员级构造器。这些构造器可以用于构造新的<code>Rect</code>实例：</p>
<pre><code class="lang-swift">let defaultRect = Rect()
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
size: Size(width: 5.0, height: 5.0))
</code></pre><p>你可以提供一个额外的使用特殊中心点和大小的构造器来扩展<code>Rect</code>结构体：</p>
<pre><code>extension Rect {
</code></pre>
<p>你可以提供一个额外的使用特殊中心点和大小的构造器来扩展<code>Rect</code>结构体：</p>
<pre><code class="lang-swift">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)
}
}
</code></pre><p>这个新的构造器首先根据提供的<code>center</code>和<code>size</code>值计算一个合适的原点。然后调用该结构体自动的成员构造器<code>init(origin:size:)</code>，该构造器将新的原点和大小存到了合适的属性中：</p>
<pre><code>let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
</code></pre>
<p>这个新的构造器首先根据提供的<code>center</code>和<code>size</code>值计算一个合适的原点。然后调用该结构体自动的成员构造器<code>init(origin:size:)</code>，该构造器将新的原点和大小存到了合适的属性中：</p>
<pre><code class="lang-swift">let centerRect = Rect(center: Point(x: 4.0, y: 4.0),
size: Size(width: 3.0, height: 3.0))
// centerRect的原点是 (2.5, 2.5)，大小是 (3.0, 3.0)
</code></pre><blockquote>
<p>注意：</p>
<p>如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。</p>
</code></pre>
<blockquote>
<p>注意：<br>如果你使用扩展提供了一个新的构造器，你依旧有责任保证构造过程能够让所有实例完全初始化。</p>
</blockquote>
<p><a name="methods"></a></p>
<h2 id="-methods-">方法（Methods）</h2>
<p>扩展可以向已有类型添加新的实例方法和类型方法。下面的例子向<code>Int</code>类型添加一个名为<code>repetitions</code>的新实例方法：</p>
<pre><code>extension Int {
<pre><code class="lang-swift">extension Int {
func repetitions(task: () -&gt; ()) {
for i in 0..self {
task()
}
}
}
</code></pre><p>这个<code>repetitions</code>方法使用了一个<code>() -&gt; ()</code>类型的单参数（single argument），表明函数没有参数而且没有返回值。</p>
</code></pre>
<p>这个<code>repetitions</code>方法使用了一个<code>() -&gt; ()</code>类型的单参数（single argument），表明函数没有参数而且没有返回值。</p>
<p>定义该扩展之后，你就可以对任意整数调用<code>repetitions</code>方法,实现的功能则是多次执行某任务：</p>
<pre><code>3.repetitions({
<pre><code class="lang-swift">3.repetitions({
println(&quot;Hello!&quot;)
})
// Hello!
// Hello!
// Hello!
</code></pre><p>可以使用 trailing 闭包使调用更加简洁：</p>
<pre><code>3.repetitions{
</code></pre>
<p>可以使用 trailing 闭包使调用更加简洁：</p>
<pre><code class="lang-swift">3.repetitions{
println(&quot;Goodbye!&quot;)
}
// Goodbye!
// Goodbye!
// Goodbye!
</code></pre><p><a name="mutating_instance_methods"></a></p>
</code></pre>
<p><a name="mutating_instance_methods"></a></p>
<h3 id="-mutating-instance-methods-">修改实例方法（Mutating Instance Methods）</h3>
<p>通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改<code>self</code>或其属性的方法必须将该实例方法标注为<code>mutating</code>，正如来自原始实现的修改方法一样。</p>
<p>下面的例子向Swift的<code>Int</code>类型添加了一个新的名为<code>square</code>的修改方法，来实现一个原始值的平方计算：</p>
<pre><code>extension Int {
<pre><code class="lang-swift">extension Int {
mutating func square() {
self = self * self
}
@ -732,7 +738,8 @@ let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),
var someInt = 3
someInt.square()
// someInt 现在值是 9
</code></pre><p><a name="subscripts"></a></p>
</code></pre>
<p><a name="subscripts"></a></p>
<h2 id="-subscripts-">下标（Subscripts）</h2>
<p>扩展可以向一个已有类型添加新下标。这个例子向Swift内建类型<code>Int</code>添加了一个整型下标。该下标<code>[n]</code>返回十进制数字从右向左数的第n个数字</p>
<ul>
@ -740,7 +747,7 @@ someInt.square()
<li>123456789[1]返回8</li>
</ul>
<p>...等等</p>
<pre><code>extension Int {
<pre><code class="lang-swift">extension Int {
subscript(digitIndex: Int) -&gt; Int {
var decimalBase = 1
for _ in 1...digitIndex {
@ -757,14 +764,16 @@ someInt.square()
// returns 2
746381295[8]
// returns 7
</code></pre><p>如果该<code>Int</code>值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：</p>
<pre><code>746381295[9]
</code></pre>
<p>如果该<code>Int</code>值没有足够的位数，即下标越界，那么上述实现的下标会返回0，因为它会在数字左边自动补0：</p>
<pre><code class="lang-swift">746381295[9]
//returns 0, 即等同于：
0746381295[9]
</code></pre><p><a name="nested_types"></a></p>
</code></pre>
<p><a name="nested_types"></a></p>
<h2 id="-nested-types-">嵌套类型（Nested Types）</h2>
<p>扩展可以向已有的类、结构体和枚举添加新的嵌套类型：</p>
<pre><code>extension Character {
<pre><code class="lang-swift">extension Character {
enum Kind {
case Vowel, Consonant, Other
}
@ -780,10 +789,11 @@ someInt.square()
}
}
}
</code></pre><p>该例子向<code>Character</code>添加了新的嵌套枚举。这个名为<code>Kind</code>的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。</p>
</code></pre>
<p>该例子向<code>Character</code>添加了新的嵌套枚举。这个名为<code>Kind</code>的枚举表示特定字符的类型。具体来说，就是表示一个标准的拉丁脚本中的字符是元音还是辅音（不考虑口语和地方变种），或者是其它类型。</p>
<p>这个类子还向<code>Character</code>添加了一个新的计算实例属性，即<code>kind</code>，用来返回合适的<code>Kind</code>枚举成员。</p>
<p>现在，这个嵌套枚举可以和一个<code>Character</code>值联合使用了：</p>
<pre><code>func printLetterKinds(word: String) {
<pre><code class="lang-swift">func printLetterKinds(word: String) {
println(&quot;&#39;\\(word)&#39; is made up of the following kinds of letters:&quot;)
for character in word {
switch character.kind {
@ -800,10 +810,10 @@ someInt.square()
printLetterKinds(&quot;Hello&quot;)
// &#39;Hello&#39; is made up of the following kinds of letters:
// consonant vowel consonant consonant vowel
</code></pre><p>函数<code>printLetterKinds</code>的输入是一个<code>String</code>值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的<code>kind</code>计算属性，并打印出合适的类别描述。所以<code>printLetterKinds</code>就可以用来打印一个完整单词中所有字母的类型，正如上述单词<code>&quot;hello&quot;</code>所展示的。</p>
</code></pre>
<p>函数<code>printLetterKinds</code>的输入是一个<code>String</code>值并对其字符进行迭代。在每次迭代过程中，考虑当前字符的<code>kind</code>计算属性，并打印出合适的类别描述。所以<code>printLetterKinds</code>就可以用来打印一个完整单词中所有字母的类型，正如上述单词<code>&quot;hello&quot;</code>所展示的。</p>
<blockquote>
<p>注意：</p>
<p>由于已知<code>character.kind</code>是<code>Character.Kind</code>型，所以<code>Character.Kind</code>中的所有成员值都可以使用<code>switch</code>语句里的形式简写，比如使用 <code>.Vowel</code>代替<code>Character.Kind.Vowel</code></p>
<p>注意：<br>由于已知<code>character.kind</code>是<code>Character.Kind</code>型，所以<code>Character.Kind</code>中的所有成员值都可以使用<code>switch</code>语句里的形式简写，比如使用 <code>.Vowel</code>代替<code>Character.Kind.Vowel</code></p>
</blockquote>

265
chapter2/21_Protocols.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.21" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.21" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,11 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_74">
<section class="normal" id="section-gitbook_550">
<blockquote>
<p>翻译：geek5nan</p>
<p>校对：dabing1022</p>
<p>翻译：geek5nan
校对：dabing1022</p>
</blockquote>
<h1 id="-">协议</h1>
<hr>
@ -604,7 +604,7 @@
<li><a href="#protocols_as_types">协议类型（Protocols as Types）</a></li>
<li><a href="#delegation">委托(代理)模式（Delegation）</a></li>
<li><a href="#adding_protocol_conformance_with_an_extension">在扩展中添加协议成员（Adding Protocol Conformance with an Extension）</a></li>
<li><a href="#declaring_protocol_adoption_with_an_extension">通过延展补充协议声明（Declaring Protocol Adoption with an Extension）</a></li>
<li><a href="#declaring_protocol_adoption_with_an_extension">通过扩展补充协议声明（Declaring Protocol Adoption with an Extension）</a></li>
<li><a href="#collections_of_protocol_types">集合中的协议类型（Collections of Protocol Types）</a></li>
<li><a href="#protocol_inheritance">协议的继承（Protocol Inheritance）</a></li>
<li><a href="#protocol_composition">协议合成（Protocol Composition）</a></li>
@ -616,42 +616,49 @@
<p><a name="protocol_syntax"></a></p>
<h2 id="-">协议的语法</h2>
<p><code>协议</code>的定义与类，结构体，枚举的定义非常相似，如下所示：</p>
<pre><code>protocol SomeProtocol {
<pre><code class="lang-swift">protocol SomeProtocol {
// 协议内容
}
</code></pre><p>在类，结构体，枚举的名称后加上<code>协议名称</code>，中间以冒号<code>:</code>分隔即可实现协议；实现多个协议时，各协议之间用逗号<code>,</code>分隔，如下所示：</p>
<pre><code>struct SomeStructure: FirstProtocol, AnotherProtocol {
</code></pre>
<p>在类，结构体，枚举的名称后加上<code>协议名称</code>，中间以冒号<code>:</code>分隔即可实现协议；实现多个协议时，各协议之间用逗号<code>,</code>分隔，如下所示：</p>
<pre><code class="lang-swift">struct SomeStructure: FirstProtocol, AnotherProtocol {
// 结构体内容
}
</code></pre><p>当某个类含有父类的同时并实现了协议，应当把父类放在所有的协议之前，如下所示：</p>
<pre><code>class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
</code></pre>
<p>当某个类含有父类的同时并实现了协议，应当把父类放在所有的协议之前，如下所示：</p>
<pre><code class="lang-swift">class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
}
</code></pre><p><a name="property_requirements"></a></p>
</code></pre>
<p><a name="property_requirements"></a></p>
<h2 id="-">属性要求</h2>
<p><code>协议</code>能够要求其<code>遵循者</code>必须含有一些<strong>特定名称和类型</strong>的<code>实例属性(instance property)</code>或<code>类属性 (type property)</code>，也能够要求属性的<code>(设置权限)settable</code> 和<code>(访问权限)gettable</code>，但它不要求<code>属性</code>是<code>存储型属性(stored property)</code>还是<code>计算型属性(calculate property)</code>。</p>
<p><code>协议</code>能够要求其<code>遵循者</code>必须含有一些<strong>特定名称和类型</strong>的<code>实例属性(instance property)</code>或<code>类属性 (type property)</code>，也能够要求属性具有<code>(设置权限)settable</code> 和<code>(访问权限)gettable</code>，但它不要求<code>属性</code>是<code>存储型属性(stored property)</code>还是<code>计算型属性(calculate property)</code>。</p>
<p>如果协议要求属性具有设置权限和访问权限，那常量存储型属性或者只读计算型属性都无法满足此要求。如果协议只要求属性具有访问权限，那任何类型的属性都可以满足此要求，无论这些属性是否具有设置权限。</p>
<p>通常前置<code>var</code>关键字将属性声明为变量。在属性声明后写上<code>{ get set }</code>表示属性为可读写的。<code>{ get }</code>用来表示属性为可读的。即使你为可读的属性实现了<code>setter</code>方法，它也不会出错。</p>
<pre><code>protocol SomeProtocol {
<pre><code class="lang-swift">protocol SomeProtocol {
var musBeSettable : Int { get set }
var doesNotNeedToBeSettable: Int { get }
}
</code></pre><p>用类来实现协议时，使用<code>class</code>关键字来表示该属性为类成员；用结构体或枚举实现协议时，则使用<code>static</code>关键字来表示：</p>
<pre><code>protocol AnotherProtocol {
</code></pre>
<p>用类来实现协议时，使用<code>class</code>关键字来表示该属性为类成员；用结构体或枚举实现协议时，则使用<code>static</code>关键字来表示：</p>
<pre><code class="lang-swift">protocol AnotherProtocol {
class var someTypeProperty: Int { get set }
}
protocol FullyNamed {
var fullName: String { get }
}
</code></pre><p><code>FullyNamed</code>协议含有<code>fullName</code>属性。因此其<code>遵循者</code>必须含有一个名为<code>fullName</code>，类型为<code>String</code>的可读属性。</p>
<pre><code>struct Person: FullyNamed{
</code></pre>
<p><code>FullyNamed</code>协议含有<code>fullName</code>属性。因此其<code>遵循者</code>必须含有一个名为<code>fullName</code>，类型为<code>String</code>的可读属性。</p>
<pre><code class="lang-swift">struct Person: FullyNamed{
var fullName: String
}
let john = Person(fullName: &quot;John Appleseed&quot;)
//john.fullName 为 &quot;John Appleseed&quot;
</code></pre><p><code>Person</code>结构体含有一个名为<code>fullName</code>的<code>存储型属性</code>，完整的<code>遵循</code>了协议。(<em>若协议未被完整遵循，编译时则会报错</em>)。</p>
</code></pre>
<p><code>Person</code>结构体含有一个名为<code>fullName</code>的<code>存储型属性</code>，完整的<code>遵循</code>了协议。(<em>若协议未被完整遵循，编译时则会报错</em>)。</p>
<p>如下所示，<code>Startship</code>类<code>遵循</code>了<code>FullyNamed</code>协议：</p>
<pre><code>class Starship: FullyNamed {
<pre><code class="lang-swift">class Starship: FullyNamed {
var prefix: String?
var name: String
init(name: String, prefix: String? = nil ) {
@ -664,25 +671,27 @@ let john = Person(fullName: &quot;John Appleseed&quot;)
}
var ncc1701 = Starship(name: &quot;Enterprise&quot;, prefix: &quot;USS&quot;)
// ncc1701.fullName == &quot;USS Enterprise&quot;
</code></pre><p><code>Starship</code>类将<code>fullName</code>实现为可读的<code>计算型属性</code>。它的每一个实例都有一个名为<code>name</code>的必备属性和一个名为<code>prefix</code>的可选属性。 当<code>prefix</code>存在时，将<code>prefix</code>插入到<code>name</code>之前来为<code>Starship</code>构建<code>fullName</code>。</p>
</code></pre>
<p><code>Starship</code>类将<code>fullName</code>实现为可读的<code>计算型属性</code>。它的每一个实例都有一个名为<code>name</code>的必备属性和一个名为<code>prefix</code>的可选属性。 当<code>prefix</code>存在时，将<code>prefix</code>插入到<code>name</code>之前来为<code>Starship</code>构建<code>fullName</code>。</p>
<p><a name="method_requirements"></a></p>
<h2 id="-">方法要求</h2>
<p><code>协议</code>能够要求其<code>遵循者</code>必备某些特定的<code>实例方法</code>和<code>类方法</code>。协议方法的声明与普通方法声明相似，但它不需要<code>方法</code>内容。</p>
<blockquote>
<p>注意：</p>
<p>协议方法支持<code>变长参数(variadic parameter)</code>，不支持<code>默认参数(default parameter)</code>。</p>
<p>注意：
协议方法支持<code>变长参数(variadic parameter)</code>，不支持<code>默认参数(default parameter)</code>。</p>
</blockquote>
<p>前置<code>class</code>关键字表示协议中的成员为<code>类成员</code>；当协议用于被<code>枚举</code>或<code>结构体</code>遵循时，则使用<code>static</code>关键字。如下所示：</p>
<pre><code>protocol SomeProtocol {
<pre><code class="lang-swift">protocol SomeProtocol {
class func someTypeMethod()
}
protocol RandomNumberGenerator {
func random() -&gt; Double
}
</code></pre><p><code>RandomNumberGenerator</code>协议要求其<code>遵循者</code>必须拥有一个名为<code>random</code>， 返回值类型为<code>Double</code>的实例方法。(我们假设随机数在[0，1]区间内)。</p>
</code></pre>
<p><code>RandomNumberGenerator</code>协议要求其<code>遵循者</code>必须拥有一个名为<code>random</code>， 返回值类型为<code>Double</code>的实例方法。(我们假设随机数在[0，1]区间内)。</p>
<p><code>LinearCongruentialGenerator</code>类<code>遵循</code>了<code>RandomNumberGenerator</code>协议，并提供了一个叫做<em>线性同余生成器(linear congruential generator)</em>的伪随机数算法。</p>
<pre><code>class LinearCongruentialGenerator: RandomNumberGenerator {
<pre><code class="lang-swift">class LinearCongruentialGenerator: RandomNumberGenerator {
var lastRandom = 42.0
let m = 139968.0
let a = 3877.0
@ -697,21 +706,23 @@ println(&quot;Here&#39;s a random number: \(generator.random())&quot;)
// 输出 : &quot;Here&#39;s a random number: 0.37464991998171&quot;
println(&quot;And another one: \(generator.random())&quot;)
// 输出 : &quot;And another one: 0.729023776863283&quot;
</code></pre><p><a name="mutating_method_requirements"></a></p>
</code></pre>
<p><a name="mutating_method_requirements"></a></p>
<h2 id="-">突变方法要求</h2>
<p>能在<code>方法</code>或<code>函数</code>内部改变实例类型的方法称为<code>突变方法</code>。在<code>值类型(Value Type)</code>(<em>译者注：特指结构体和枚举</em>)中的的<code>函数</code>前缀加上<code>mutating</code>关键字来表示该函数允许改变该实例和其属性的类型。 这一变换过程在<a href="11_Methods.html#instance_methods">实例方法(Instance Methods)</a>章节中有详细描述。</p>
<p>(<em>译者注：类中的成员为<code>引用类型(Reference Type)</code>，可以方便的修改实例及其属性的值而无需改变类型；而<code>结构体</code>和<code>枚举</code>中的成员均为<code>值类型(Value Type)</code>，修改变量的值就相当于修改变量的类型，而<code>Swift</code>默认不允许修改类型，因此需要前置<code>mutating</code>关键字用来表示该<code>函数</code>中能够修改类型</em>)</p>
<blockquote>
<p>注意：</p>
<p>用<code>class</code>实现协议中的<code>mutating</code>方法时，不用写<code>mutating</code>关键字；用<code>结构体</code>，<code>枚举</code>实现协议中的<code>mutating</code>方法时，必须写<code>mutating</code>关键字。</p>
<p>注意：
用<code>class</code>实现协议中的<code>mutating</code>方法时，不用写<code>mutating</code>关键字；用<code>结构体</code>，<code>枚举</code>实现协议中的<code>mutating</code>方法时，必须写<code>mutating</code>关键字。</p>
</blockquote>
<p>如下所示，<code>Togglable</code>协议含有<code>toggle</code>函数。根据函数名称推测，<code>toggle</code>可能用于<strong>切换或恢复</strong>某个属性的状态。<code>mutating</code>关键字表示它为<code>突变方法</code>：</p>
<pre><code>protocol Togglable {
<pre><code class="lang-swift">protocol Togglable {
mutating func toggle()
}
</code></pre><p>当使用<code>枚举</code>或<code>结构体</code>来实现<code>Togglabl</code>协议时，必须在<code>toggle</code>方法前加上<code>mutating</code>关键字。</p>
</code></pre>
<p>当使用<code>枚举</code>或<code>结构体</code>来实现<code>Togglabl</code>协议时，必须在<code>toggle</code>方法前加上<code>mutating</code>关键字。</p>
<p>如下所示，<code>OnOffSwitch</code>枚举<code>遵循</code>了<code>Togglable</code>协议，<code>On</code>，<code>Off</code>两个成员用于表示当前状态</p>
<pre><code>enum OnOffSwitch: Togglable {
<pre><code class="lang-swift">enum OnOffSwitch: Togglable {
case Off, On
mutating func toggle() {
switch self {
@ -725,7 +736,8 @@ println(&quot;And another one: \(generator.random())&quot;)
var lightSwitch = OnOffSwitch.Off
lightSwitch.toggle()
//lightSwitch 现在的值为 .On
</code></pre><p><a name="protocols_as_types"></a></p>
</code></pre>
<p><a name="protocols_as_types"></a></p>
<h2 id="-">协议类型</h2>
<p><code>协议</code>本身不实现任何功能，但你可以将它当做<code>类型</code>来使用。</p>
<p>使用场景：</p>
@ -735,10 +747,10 @@ lightSwitch.toggle()
<li>作为数组，字典或其他容器中的元素类型</li>
</ul>
<blockquote>
<p>注意：</p>
<p>协议类型应与其他类型(Int，Double，String)的写法相同，使用驼峰式</p>
<p>注意：
协议类型应与其他类型(Int，Double，String)的写法相同，使用驼峰式</p>
</blockquote>
<pre><code>class Dice {
<pre><code class="lang-swift">class Dice {
let sides: Int
let generator: RandomNumberGenerator
init(sides: Int, generator: RandomNumberGenerator) {
@ -749,12 +761,13 @@ lightSwitch.toggle()
return Int(generator.random() * Double(sides)) +1
}
}
</code></pre><p>这里定义了一个名为 <code>Dice</code>的类，用来代表桌游中的N个面的骰子。</p>
<p> <code>Dice</code>含有<code>sides</code>和<code>generator</code>两个属性，前者用来表示骰子有几个面，后者为骰子提供一个随机数生成器。由于后者为<code>RandomNumberGenerator</code>的协议类型。所以它能够被赋值为任意<code>遵循</code>该协议的类型。</p>
</code></pre>
<p>这里定义了一个名为 <code>Dice</code>的类，用来代表桌游中的N个面的骰子。</p>
<p><code>Dice</code>含有<code>sides</code>和<code>generator</code>两个属性，前者用来表示骰子有几个面，后者为骰子提供一个随机数生成器。由于后者为<code>RandomNumberGenerator</code>的协议类型。所以它能够被赋值为任意<code>遵循</code>该协议的类型。</p>
<p>此外，使用<code>构造器(init)</code>来代替之前版本中的<code>setup</code>操作。构造器中含有一个名为<code>generator</code>，类型为<code>RandomNumberGenerator</code>的形参，使得它可以接收任意遵循<code>RandomNumberGenerator</code>协议的类型。</p>
<p><code>roll</code>方法用来模拟骰子的面值。它先使用<code>generator</code>的<code>random</code>方法来创建一个[0-1]区间内的随机数种子，然后加工这个随机数种子生成骰子的面值。</p>
<p>如下所示，<code>LinearCongruentialGenerator</code>的实例作为随机数生成器传入<code>Dice</code>的<code>构造器</code></p>
<pre><code>var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
<pre><code class="lang-swift">var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
for _ in 1...5 {
println(&quot;Random dice roll is \(d6.roll())&quot;)
}
@ -764,24 +777,27 @@ for _ in 1...5 {
//Random dice roll is 4
//Random dice roll is 5
//Random dice roll is 4
</code></pre><p><a name="delegation"></a></p>
</code></pre>
<p><a name="delegation"></a></p>
<h2 id="-">委托(代理)模式</h2>
<p>委托是一种设计模式，它允许类或结构体将一些需要它们负责的功能<code>交由(委托)</code>给其他的类型。</p>
<p>委托模式的实现很简单： 定义<code>协议</code>来<code>封装</code>那些需要被委托的<code>函数和方法</code>， 使其<code>遵循者</code>拥有这些被委托的<code>函数和方法</code>。</p>
<p>委托模式可以用来响应特定的动作或接收外部数据源提供的数据，而无需要知道外部数据源的类型。</p>
<p>下文是两个基于骰子游戏的协议：</p>
<pre><code>protocol DiceGame {
<pre><code class="lang-swift">protocol DiceGame {
var dice: Dice { get }
func play()
}
protocol DiceGameDelegate {
func gameDidStart(game: DiceGame)
func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int)
func gameDidEnd(game: DiceGame)
}
</code></pre><p><code>DiceGame</code>协议可以在任意含有骰子的游戏中实现，<code>DiceGameDelegate</code>协议可以用来追踪<code>DiceGame</code>的游戏过程。</p>
</code></pre>
<p><code>DiceGame</code>协议可以在任意含有骰子的游戏中实现，<code>DiceGameDelegate</code>协议可以用来追踪<code>DiceGame</code>的游戏过程。</p>
<p>如下所示，<code>SnakesAndLadders</code>是<code>Snakes and Ladders</code>(译者注：<a href="05_Control_Flow.html">控制流</a>章节有该游戏的详细介绍)游戏的新版本。新版本使用<code>Dice</code>作为骰子，并且实现了<code>DiceGame</code>和<code>DiceGameDelegate</code>协议</p>
<pre><code>class SnakesAndLadders: DiceGame {
<pre><code class="lang-swift">class SnakesAndLadders: DiceGame {
let finalSquare = 25
let dic = Dice(sides: 6, generator: LinearCongruentialGenerator())
var square = 0
@ -811,15 +827,16 @@ protocol DiceGameDelegate {
delegate?.gameDIdEnd(self)
}
}
</code></pre><p>游戏的<code>初始化设置(setup)</code>被<code>SnakesAndLadders</code>类的<code>构造器(initializer)</code>实现。所有的游戏逻辑被转移到了<code>play</code>方法中。</p>
</code></pre>
<p>游戏的<code>初始化设置(setup)</code>被<code>SnakesAndLadders</code>类的<code>构造器(initializer)</code>实现。所有的游戏逻辑被转移到了<code>play</code>方法中。</p>
<blockquote>
<p>注意：</p>
<p>因为<code>delegate</code>并不是该游戏的必备条件，<code>delegate</code>被定义为遵循<code>DiceGameDelegate</code>协议的可选属性</p>
<p>注意：
因为<code>delegate</code>并不是该游戏的必备条件，<code>delegate</code>被定义为遵循<code>DiceGameDelegate</code>协议的可选属性</p>
</blockquote>
<p><code>DicegameDelegate</code>协议提供了三个方法用来追踪游戏过程。被放置于游戏的逻辑中，即<code>play()</code>方法内。分别在游戏开始时，新一轮开始时，游戏结束时被调用。</p>
<p>因为<code>delegate</code>是一个遵循<code>DiceGameDelegate</code>的可选属性，因此在<code>play()</code>方法中使用了<code>可选链</code>来调用委托方法。 若<code>delegate</code>属性为<code>nil</code>， 则委托调用<em>优雅地</em>失效。若<code>delegate</code>不为<code>nil</code>，则委托方法被调用</p>
<p>如下所示，<code>DiceGameTracker</code>遵循了<code>DiceGameDelegate</code>协议</p>
<pre><code>class DiceGameTracker: DiceGameDelegate {
<pre><code class="lang-swift">class DiceGameTracker: DiceGameDelegate {
var numberOfTurns = 0
func gameDidStart(game: DiceGame) {
numberOfTurns = 0
@ -836,10 +853,11 @@ protocol DiceGameDelegate {
println(&quot;The game lasted for \(numberOfTurns) turns&quot;)
}
}
</code></pre><p><code>DiceGameTracker</code>实现了<code>DiceGameDelegate</code>协议的方法要求，用来记录游戏已经进行的轮数。 当游戏开始时，<code>numberOfTurns</code>属性被赋值为0；在每新一轮中递加；游戏结束后，输出打印游戏的总轮数。</p>
</code></pre>
<p><code>DiceGameTracker</code>实现了<code>DiceGameDelegate</code>协议的方法要求，用来记录游戏已经进行的轮数。 当游戏开始时，<code>numberOfTurns</code>属性被赋值为0；在每新一轮中递加；游戏结束后，输出打印游戏的总轮数。</p>
<p><code>gameDidStart</code>方法从<code>game</code>参数获取游戏信息并输出。<code>game</code>在方法中被当做<code>DiceGame</code>类型而不是<code>SnakeAndLadders</code>类型，所以方法中只能访问<code>DiceGame</code>协议中的成员。</p>
<p><code>DiceGameTracker</code>的运行情况，如下所示：</p>
<pre><code>“let tracker = DiceGameTracker()
<pre><code class="lang-swift">let tracker = DiceGameTracker()
let game = SnakesAndLadders()
game.delegate = tracker
game.play()
@ -849,80 +867,91 @@ game.play()
// Rolled a 5
// Rolled a 4
// Rolled a 5
// The game lasted for 4 turns”
</code></pre><p><a name="adding_protocol_conformance_with_an_extension"></a></p>
// The game lasted for 4 turns
</code></pre>
<p><a name="adding_protocol_conformance_with_an_extension"></a></p>
<h2 id="-">在扩展中添加协议成员</h2>
<p>即便无法修改源代码，依然可以通过<code>扩展(Extension)</code>来扩充已存在类型(<em>译者注： 类，结构体，枚举等</em>)。<code>扩展</code>可以为已存在的类型添加<code>属性</code>，<code>方法</code>，<code>下标</code>，<code>协议</code>等成员。详情请在<a href="20_Extensions.html">扩展</a>章节中查看。</p>
<blockquote>
<p>注意：</p>
<p>通过<code>扩展</code>为已存在的类型<code>遵循</code>协议时，该类型的所有实例也会随之添加协议中的方法</p>
<p>注意：
通过<code>扩展</code>为已存在的类型<code>遵循</code>协议时，该类型的所有实例也会随之添加协议中的方法</p>
</blockquote>
<p><code>TextRepresentable</code>协议含有一个<code>asText</code>，如下所示：</p>
<pre><code>protocol TextRepresentable {
<pre><code class="lang-swift">protocol TextRepresentable {
func asText() -&gt; String
}
</code></pre><p>通过<code>扩展</code>为上一节中提到的<code>Dice</code>类遵循<code>TextRepresentable</code>协议</p>
<pre><code>extension Dice: TextRepresentable {
func asText() -&gt; String {
</code></pre>
<p>通过<code>扩展</code>为上一节中提到的<code>Dice</code>类遵循<code>TextRepresentable</code>协议</p>
<pre><code class="lang-swift">extension Dice: TextRepresentable {
cun asText() -&gt; String {
return &quot;A \(sides)-sided dice&quot;
}
}
</code></pre><p>从现在起，<code>Dice</code>类型的实例可被当作<code>TextRepresentable</code>类型：</p>
<pre><code>let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
</code></pre>
<p>从现在起，<code>Dice</code>类型的实例可被当作<code>TextRepresentable</code>类型：</p>
<pre><code class="lang-swift">let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
println(d12.asText())
// 输出 &quot;A 12-sided dice&quot;
</code></pre><p><code>SnakesAndLadders</code>类也可以通过<code>扩展</code>的方式来遵循协议：</p>
<pre><code>extension SnakeAndLadders: TextRepresentable {
</code></pre>
<p><code>SnakesAndLadders</code>类也可以通过<code>扩展</code>的方式来遵循协议：</p>
<pre><code class="lang-swift">extension SnakeAndLadders: TextRepresentable {
func asText() -&gt; String {
return &quot;A game of Snakes and Ladders with \(finalSquare) squares&quot;
}
}
println(game.asText())
// 输出 &quot;A game of Snakes and Ladders with 25 squares&quot;
</code></pre><p><a name="declaring_protocol_adoption_with_an_extension"></a></p>
<h2 id="-">通过延展补充协议声明</h2>
</code></pre>
<p><a name="declaring_protocol_adoption_with_an_extension"></a></p>
<h2 id="-">通过扩展补充协议声明</h2>
<p>当一个类型已经实现了协议中的所有要求，却没有声明时，可以通过<code>扩展</code>来补充协议声明：</p>
<pre><code>struct Hamster {
<pre><code class="lang-swift">struct Hamster {
var name: String
func asText() -&gt; String {
return &quot;A hamster named \(name)&quot;
}
}
extension Hamster: TextRepresentabl {}
</code></pre><p>从现在起，<code>Hamster</code>的实例可以作为<code>TextRepresentable</code>类型使用</p>
<pre><code>let simonTheHamster = Hamster(name: &quot;Simon&quot;)
</code></pre>
<p>从现在起，<code>Hamster</code>的实例可以作为<code>TextRepresentable</code>类型使用</p>
<pre><code class="lang-swift">let simonTheHamster = Hamster(name: &quot;Simon&quot;)
let somethingTextRepresentable: TextRepresentabl = simonTheHamester
println(somethingTextRepresentable.asText())
// 输出 &quot;A hamster named Simon&quot;
</code></pre><blockquote>
<p>注意：</p>
<p>即时满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明</p>
</code></pre>
<blockquote>
<p>注意：
即时满足了协议的所有要求，类型也不会自动转变，因此你必须为它做出明显的协议声明</p>
</blockquote>
<p><a name="collections_of_protocol_types"></a></p>
<h2 id="-">集合中的协议类型</h2>
<p>协议类型可以被集合使用，表示集合中的元素均为协议类型：</p>
<pre><code>let things: TextRepresentable[] = [game,d12,simoTheHamster]
</code></pre><p>如下所示，<code>things</code>数组可以被直接遍历，并调用其中元素的<code>asText()</code>函数：</p>
<pre><code>for thing in things {
<pre><code class="lang-swift">let things: TextRepresentable[] = [game,d12,simoTheHamster]
</code></pre>
<p>如下所示，<code>things</code>数组可以被直接遍历，并调用其中元素的<code>asText()</code>函数：</p>
<pre><code class="lang-swift">for thing in things {
println(thing.asText())
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon
</code></pre><p><code>thing</code>被当做是<code>TextRepresentable</code>类型而不是<code>Dice</code>，<code>DiceGame</code>，<code>Hamster</code>等类型。因此能且仅能调用<code>asText</code>方法</p>
</code></pre>
<p><code>thing</code>被当做是<code>TextRepresentable</code>类型而不是<code>Dice</code>，<code>DiceGame</code>，<code>Hamster</code>等类型。因此能且仅能调用<code>asText</code>方法</p>
<p><a name="protocol_inheritance"></a></p>
<h2 id="-">协议的继承</h2>
<p>协议能够<em>继承</em>一到多个其他协议。语法与类的继承相似，多个协议间用逗号<code>,</code>分隔</p>
<pre><code>protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
<pre><code class="lang-swift">protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// 协议定义
}
</code></pre><p>如下所示，<code>PrettyTextRepresentable</code>协议继承了<code>TextRepresentable</code>协议</p>
<pre><code>protocol PrettyTextRepresentable: TextRepresentable {
</code></pre>
<p>如下所示，<code>PrettyTextRepresentable</code>协议继承了<code>TextRepresentable</code>协议</p>
<pre><code class="lang-swift">protocol PrettyTextRepresentable: TextRepresentable {
func asPrettyText() -&gt; String
}
</code></pre><p><code>遵循``PrettyTextRepresentable</code>协议的同时，也需要<code>遵循</code>TextRepresentable`协议。</p>
</code></pre>
<p><code>遵循``PrettyTextRepresentable</code>协议的同时，也需要<code>遵循</code>TextRepresentable`协议。</p>
<p>如下所示，用<code>扩展</code>为<code>SnakesAndLadders</code>遵循<code>PrettyTextRepresentable</code>协议：</p>
<pre><code>extension SnakesAndLadders: PrettyTextRepresentable {
<pre><code class="lang-swift">extension SnakesAndLadders: PrettyTextRepresentable {
func asPrettyText() -&gt; String {
var output = asText() + &quot;:\n&quot;
for index in 1...finalSquare {
@ -938,21 +967,23 @@ println(somethingTextRepresentable.asText())
return output
}
}
</code></pre><p>在<code>for in</code>中迭代出了<code>board</code>数组中的每一个元素：</p>
</code></pre>
<p>在<code>for in</code>中迭代出了<code>board</code>数组中的每一个元素：</p>
<ul>
<li>当从数组中迭代出的元素的值大于0时，用<code>▲</code>表示</li>
<li>当从数组中迭代出的元素的值小于0时，用<code>▼</code>表示</li>
<li>当从数组中迭代出的元素的值等于0时，用<code>○</code>表示</li>
</ul>
<p>任意<code>SankesAndLadders</code>的实例都可以使用<code>asPrettyText()</code>方法。</p>
<pre><code>println(game.asPrettyText())
<pre><code class="lang-swift">println(game.asPrettyText())
// A game of Snakes and Ladders with 25 squares:
// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○
</code></pre><p><a name="protocol_composition"></a></p>
</code></pre>
<p><a name="protocol_composition"></a></p>
<h2 id="-">协议合成</h2>
<p>一个协议可由多个协议采用<code>protocol&lt;SomeProtocol, AnotherProtocol&gt;</code>这样的格式进行组合，称为<code>协议合成(protocol composition)</code>。</p>
<p>举个例子：</p>
<pre><code>protocol Named {
<pre><code class="lang-swift">protocol Named {
var name: String { get }
}
protocol Aged {
@ -968,11 +999,12 @@ func wishHappyBirthday(celebrator: protocol&lt;Named, Aged&gt;) {
let birthdayPerson = Person(name: &quot;Malcolm&quot;, age: 21)
wishHappyBirthday(birthdayPerson)
// 输出 &quot;Happy birthday Malcolm - you&#39;re 21!
</code></pre><p><code>Named</code>协议包含<code>String</code>类型的<code>name</code>属性；<code>Aged</code>协议包含<code>Int</code>类型的<code>age</code>属性。<code>Person</code>结构体<code>遵循</code>了这两个协议。</p>
</code></pre>
<p><code>Named</code>协议包含<code>String</code>类型的<code>name</code>属性；<code>Aged</code>协议包含<code>Int</code>类型的<code>age</code>属性。<code>Person</code>结构体<code>遵循</code>了这两个协议。</p>
<p><code>wishHappyBirthday</code>函数的形参<code>celebrator</code>的类型为<code>protocol&lt;Named,Aged&gt;</code>。可以传入任意<code>遵循</code>这两个协议的类型的实例</p>
<blockquote>
<p>注意：</p>
<p><code>协议合成</code>并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。</p>
<p>注意：
<code>协议合成</code>并不会生成一个新协议类型，而是将多个协议合成为一个临时的协议，超出范围后立即失效。</p>
</blockquote>
<p><a name="checking_for_protocol_conformance"></a></p>
<h2 id="-">检验协议的一致性</h2>
@ -982,14 +1014,15 @@ wishHappyBirthday(birthdayPerson)
<li><code>as?</code>返回一个可选值，当实例<code>遵循</code>协议时，返回该协议类型；否则返回<code>nil</code></li>
<li><code>as</code>用以强制向下转换型。</li>
</ul>
<pre><code>@objc protocol HasArea {
<pre><code class="lang-swift">@objc protocol HasArea {
var area: Double { get }
}
</code></pre><blockquote>
<p>注意：</p>
<p><code>@objc</code>用来表示协议是可选的，也可以用来表示暴露给<code>Objective-C</code>的代码，此外，<code>@objc</code>型协议只对<code>类</code>有效，因此只能在<code>类</code>中检查协议的一致性。详情查看<em><a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216" target="_blank">Using Siwft with Cocoa and Objectivei-c</a></em>。</p>
</code></pre>
<blockquote>
<p>注意：
<code>@objc</code>用来表示协议是可选的，也可以用来表示暴露给<code>Objective-C</code>的代码，此外，<code>@objc</code>型协议只对<code>类</code>有效，因此只能在<code>类</code>中检查协议的一致性。详情查看<em><a href="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/index.html#//apple_ref/doc/uid/TP40014216" target="_blank">Using Siwft with Cocoa and Objectivei-c</a></em>。</p>
</blockquote>
<pre><code>class Circle: HasArea {
<pre><code class="lang-swift">class Circle: HasArea {
let pi = 3.1415927
var radius: Double
var area:≈radius }
@ -999,20 +1032,23 @@ class Country: HasArea {
var area: Double
init(area: Double) { self.area = area }
}
</code></pre><p><code>Circle</code>和<code>Country</code>都遵循了<code>HasArea</code>协议，前者把<code>area</code>写为计算型属性（computed property），后者则把<code>area</code>写为存储型属性（stored property）。</p>
</code></pre>
<p><code>Circle</code>和<code>Country</code>都遵循了<code>HasArea</code>协议，前者把<code>area</code>写为计算型属性（computed property），后者则把<code>area</code>写为存储型属性（stored property）。</p>
<p>如下所示，<code>Animal</code>类没有实现任何协议</p>
<pre><code>class Animal {
<pre><code class="lang-swift">class Animal {
var legs: Int
init(legs: Int) { self.legs = legs }
}
</code></pre><p><code>Circle,Country,Animal</code>并没有一个相同的基类，所以采用<code>AnyObject</code>类型的数组来装载在它们的实例，如下所示：</p>
<pre><code>let objects: AnyObject[] = [
</code></pre>
<p><code>Circle,Country,Animal</code>并没有一个相同的基类，所以采用<code>AnyObject</code>类型的数组来装载在它们的实例，如下所示：</p>
<pre><code class="lang-swift">let objects: AnyObject[] = [
Circle(radius: 2.0),
Country(area: 243_610),
Animal(legs: 4)
]
</code></pre><p>如下所示，在迭代时检查<code>object</code>数组的元素是否<code>遵循</code>了<code>HasArea</code>协议：</p>
<pre><code>for object in objects {
</code></pre>
<p>如下所示，在迭代时检查<code>object</code>数组的元素是否<code>遵循</code>了<code>HasArea</code>协议：</p>
<pre><code class="lang-swift">for object in objects {
if let objectWithArea = object as? HasArea {
println(&quot;Area is \(objectWithArea.area)&quot;)
} else {
@ -1022,7 +1058,8 @@ class Country: HasArea {
// Area is 12.5663708
// Area is 243610.0
// Something that doesn&#39;t have an area
</code></pre><p>当数组中的元素遵循<code>HasArea</code>协议时，通过<code>as?</code>操作符将其<code>可选绑定(optional binding)</code>到<code>objectWithArea</code>常量上。</p>
</code></pre>
<p>当数组中的元素遵循<code>HasArea</code>协议时，通过<code>as?</code>操作符将其<code>可选绑定(optional binding)</code>到<code>objectWithArea</code>常量上。</p>
<p><code>objects</code>数组中元素的类型并不会因为<code>向下转型</code>而改变，当它们被赋值给<code>objectWithArea</code>时只被视为<code>HasArea</code>类型，因此只有<code>area</code>属性能够被访问。</p>
<p><a name="optional_protocol_requirements"></a></p>
<h2 id="-">可选协议要求</h2>
@ -1030,21 +1067,22 @@ class Country: HasArea {
<p>可选协议在调用时使用<code>可选链</code>，详细内容在<a href="17_Optional_Chaining.html">可选链</a>章节中查看。</p>
<p>像<code>someOptionalMethod?(someArgument)</code>一样，你可以在可选方法名称后加上<code>?</code>来检查该方法是否被实现。<code>可选方法</code>和<code>可选属性</code>都会返回一个<code>可选值(optional value)</code>，当其不可访问时，<code>?</code>之后语句不会执行，并返回<code>nil</code>。</p>
<blockquote>
<p>注意：</p>
<p>可选协议只能在含有<code>@objc</code>前缀的协议中生效。且<code>@objc</code>的协议只能被<code>类</code>遵循。</p>
<p>注意：
可选协议只能在含有<code>@objc</code>前缀的协议中生效。且<code>@objc</code>的协议只能被<code>类</code>遵循。</p>
</blockquote>
<p><code>Counter</code>类使用<code>CounterDataSource</code>类型的外部数据源来提供<code>增量值(increment amount)</code>，如下所示：</p>
<pre><code>@objc protocol CounterDataSource {
<pre><code class="lang-swift">@objc protocol CounterDataSource {
@optional func incrementForCount(count: Int) -&gt; Int
@optional var fixedIncrement: Int { get }
}
</code></pre><p><code>CounterDataSource</code>含有<code>incrementForCount</code>的<code>可选方法</code>和<code>fiexdIncrement</code>的<code>可选属性</code>。</p>
</code></pre>
<p><code>CounterDataSource</code>含有<code>incrementForCount</code>的<code>可选方法</code>和<code>fiexdIncrement</code>的<code>可选属性</code>。</p>
<blockquote>
<p>注意：</p>
<p><code>CounterDataSource</code>中的属性和方法都是可选的，因此可以在类中声明但不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。</p>
<p>注意：
<code>CounterDataSource</code>中的属性和方法都是可选的，因此可以在类中声明但不实现这些成员，尽管技术上允许这样做，不过最好不要这样写。</p>
</blockquote>
<p><code>Counter</code>类含有<code>CounterDataSource?</code>类型的可选属性<code>dataSource</code>，如下所示：</p>
<pre><code>@objc class Counter {
<pre><code class="lang-swift">@objc class Counter {
var count = 0
var dataSource: CounterDataSource?
func increment() {
@ -1055,7 +1093,8 @@ class Country: HasArea {
}
}
}
</code></pre><p><code>count</code>属性用于存储当前的值，<code>increment</code>方法用来为<code>count</code>赋值。</p>
</code></pre>
<p><code>count</code>属性用于存储当前的值，<code>increment</code>方法用来为<code>count</code>赋值。</p>
<p><code>increment</code>方法通过<code>可选链</code>，尝试从两种<code>可选成员</code>中获取<code>count</code>。</p>
<ol>
<li>由于<code>dataSource</code>可能为<code>nil</code>，因此在<code>dataSource</code>后边加上了<code>?</code>标记来表明只在<code>dataSource</code>非空时才去调用incrementForCount`方法。</li>
@ -1064,11 +1103,12 @@ class Country: HasArea {
<p>在调用<code>incrementForCount</code>方法后，<code>Int</code>型<code>可选值</code>通过<code>可选绑定(optional binding)</code>自动拆包并赋值给常量<code>amount</code>。</p>
<p>当<code>incrementForCount</code>不能被调用时，尝试使用<code>可选属性``fixedIncrement</code>来代替。</p>
<p><code>ThreeSource</code>实现了<code>CounterDataSource</code>协议，如下所示：</p>
<pre><code>class ThreeSource: CounterDataSource {
<pre><code class="lang-swift">class ThreeSource: CounterDataSource {
let fixedIncrement = 3
}
</code></pre><p>使用<code>ThreeSource</code>作为数据源开实例化一个<code>Counter</code>：</p>
<pre><code>var counter = Counter()
</code></pre>
<p>使用<code>ThreeSource</code>作为数据源开实例化一个<code>Counter</code>：</p>
<pre><code class="lang-swift">var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
counter.increment()
@ -1078,8 +1118,9 @@ for _ in 1...4 {
// 6
// 9
// 12
</code></pre><p><code>TowardsZeroSource</code>实现了<code>CounterDataSource</code>协议中的<code>incrementForCount</code>方法，如下所示：</p>
<pre><code>class TowardsZeroSource: CounterDataSource {
</code></pre>
<p><code>TowardsZeroSource</code>实现了<code>CounterDataSource</code>协议中的<code>incrementForCount</code>方法，如下所示：</p>
<pre><code class="lang-swift">class TowardsZeroSource: CounterDataSource {
func incrementForCount(count: Int) -&gt; Int {
if count == 0 {
return 0
@ -1090,8 +1131,9 @@ func incrementForCount(count: Int) -&gt; Int {
}
}
}
</code></pre><p>下边是执行的代码：</p>
<pre><code>counter.count = -4
</code></pre>
<p>下边是执行的代码：</p>
<pre><code class="lang-swift">counter.count = -4
counter.dataSource = TowardsZeroSource()
for _ in 1...5 {
counter.increment()
@ -1103,6 +1145,7 @@ for _ in 1...5 {
// 0
// 0
</code></pre>
</section>

139
chapter2/22_Generics.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.22" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.22" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_76">
<section class="normal" id="section-gitbook_552">
<blockquote>
<p>翻译：takalard</p>
<p>校对：lifedim</p>
<p>翻译：takalard<br>校对：lifedim </p>
</blockquote>
<h1 id="-">泛型</h1>
<hr>
@ -611,20 +610,22 @@
<p><a name="the_problem_that_generics_solve"></a></p>
<h2 id="-">泛型所解决的问题</h2>
<p>这里是一个标准的，非泛型函数<code>swapTwoInts</code>,用来交换两个Int值：</p>
<pre><code>func swapTwoInts(inout a: Int, inout b: Int)
let temporaryA = a
a = b
b = temporaryA
<pre><code class="lang-swift">func swapTwoInts(inout a: Int, inout b: Int)
let temporaryA = a
a = b
b = temporaryA
}
</code></pre><p>这个函数使用写入读出（in-out）参数来交换<code>a</code>和<code>b</code>的值，请参考[写入读出参数][1]。</p>
</code></pre>
<p>这个函数使用写入读出（in-out）参数来交换<code>a</code>和<code>b</code>的值，请参考[写入读出参数][1]。</p>
<p><code>swapTwoInts</code>函数可以交换<code>b</code>的原始值到<code>a</code>，也可以交换a的原始值到<code>b</code>，你可以调用这个函数交换两个<code>Int</code>变量值：</p>
<pre><code>var someInt = 3
<pre><code class="lang-swift">var someInt = 3
var anotherInt = 107
swapTwoInts(&amp;someInt, &amp;anotherInt)
println(&quot;someInt is now \(someInt), and anotherInt is now \(anotherInt)&quot;)
// 输出 &quot;someInt is now 107, and anotherInt is now 3&quot;
</code></pre><p><code>swapTwoInts</code>函数是非常有用的，但是它只能交换<code>Int</code>值，如果你想要交换两个<code>String</code>或者<code>Double</code>，就不得不写更多的函数，如 <code>swapTwoStrings</code>和<code>swapTwoDoublesfunctions</code>，如同如下所示：</p>
<pre><code>func swapTwoStrings(inout a: String, inout b: String) {
</code></pre>
<p><code>swapTwoInts</code>函数是非常有用的，但是它只能交换<code>Int</code>值，如果你想要交换两个<code>String</code>或者<code>Double</code>，就不得不写更多的函数，如 <code>swapTwoStrings</code>和<code>swapTwoDoublesfunctions</code>，如同如下所示：</p>
<pre><code class="lang-swift">func swapTwoStrings(inout a: String, inout b: String) {
let temporaryA = a
a = b
b = temporaryA
@ -635,39 +636,41 @@ func swapTwoDoubles(inout a: Double, inout b: Double) {
a = b
b = temporaryA
}
</code></pre><p>你可能注意到 <code>swapTwoInts</code>、 <code>swapTwoStrings</code>和<code>swapTwoDoubles</code>函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是<code>Int</code>、<code>String</code>和<code>Double</code>。</p>
</code></pre>
<p>你可能注意到 <code>swapTwoInts</code>、 <code>swapTwoStrings</code>和<code>swapTwoDoubles</code>函数功能都是相同的，唯一不同之处就在于传入的变量类型不同，分别是<code>Int</code>、<code>String</code>和<code>Double</code>。</p>
<p>但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）</p>
<blockquote>
<p>注意：
在所有三个函数中，<code>a</code>和<code>b</code>的类型是一样的。如果<code>a</code>和<code>b</code>不是相同的类型，那它们俩就不能互换值。Swift 是类型安全的语言，所以它不允许一个<code>String</code>类型的变量和一个<code>Double</code>类型的变量互相交换值。如果一定要做，Swift 将报编译错误。</p>
<p>注意：<br>在所有三个函数中，<code>a</code>和<code>b</code>的类型是一样的。如果<code>a</code>和<code>b</code>不是相同的类型，那它们俩就不能互换值。Swift 是类型安全的语言，所以它不允许一个<code>String</code>类型的变量和一个<code>Double</code>类型的变量互相交换值。如果一定要做，Swift 将报编译错误。</p>
</blockquote>
<p><a name="generic_functions"></a></p>
<h2 id="-">泛型函数</h2>
<p><code>泛型函数</code>可以工作于任何类型，这里是一个上面<code>swapTwoInts</code>函数的泛型版本，用于交换两个值：</p>
<pre><code>func swapTwoValues&lt;T&gt;(inout a: T, inout b: T) {
<pre><code class="lang-swift">func swapTwoValues&lt;T&gt;(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
</code></pre><p><code>swapTwoValues</code>函数主体和<code>swapTwoInts</code>函数是一样的，它只在第一行稍微有那么一点点不同于<code>swapTwoInts</code>，如下所示：</p>
<pre><code>func swapTwoInts(inout a: Int, inout b: Int)
</code></pre>
<p><code>swapTwoValues</code>函数主体和<code>swapTwoInts</code>函数是一样的，它只在第一行稍微有那么一点点不同于<code>swapTwoInts</code>，如下所示：</p>
<pre><code class="lang-swift">func swapTwoInts(inout a: Int, inout b: Int)
func swapTwoValues&lt;T&gt;(inout a: T, inout b: T)
</code></pre><p>这个函数的泛型版本使用了占位类型名字（通常此情况下用字母<code>T</code>来表示）来代替实际类型名（如<code>In</code>、<code>String</code>或<code>Doubl</code>）。占位类型名没有提示<code>T</code>必须是什么类型，但是它提示了<code>a</code>和<code>b</code>必须是同一类型<code>T</code>，而不管<code>T</code>表示什么类型。只有<code>swapTwoValues</code>函数在每次调用时所传入的实际类型才能决定<code>T</code>所代表的类型。</p>
</code></pre>
<p>这个函数的泛型版本使用了占位类型名字（通常此情况下用字母<code>T</code>来表示）来代替实际类型名（如<code>In</code>、<code>String</code>或<code>Doubl</code>）。占位类型名没有提示<code>T</code>必须是什么类型，但是它提示了<code>a</code>和<code>b</code>必须是同一类型<code>T</code>，而不管<code>T</code>表示什么类型。只有<code>swapTwoValues</code>函数在每次调用时所传入的实际类型才能决定<code>T</code>所代表的类型。</p>
<p>另外一个不同之处在于这个泛型函数名后面跟着的展位类型名字（T）是用尖括号括起来的（<T>）。这个尖括号告诉 Swift 那个<code>T</code>是<code>swapTwoValues</code>函数所定义的一个类型。因为<code>T</code>是一个占位命名类型，Swift 不会去查找命名为T的实际类型。</p>
<p><code>swapTwoValues</code>函数除了要求传入的两个任何类型值是同一类型外，也可以作为<code>swapTwoInts</code>函数被调用。每次<code>swapTwoValues</code>被调用，T所代表的类型值都会传给函数。</p>
<p>在下面的两个例子中,<code>T</code>分别代表<code>Int</code>和<code>String</code>：</p>
<pre><code>var someInt = 3
<pre><code class="lang-swift">var someInt = 3
var anotherInt = 107
swapTwoValues(&amp;someInt, &amp;anotherInt)
// someInt is now 107, and anotherInt is now 3
var someString = &quot;hello&quot;
</code></pre>
<pre><code class="lang-swift">var someString = &quot;hello&quot;
var anotherString = &quot;world&quot;
swapTwoValues(&amp;someString, &amp;anotherString)
// someString is now &quot;world&quot;, and anotherString is now &quot;hello&quot;
</code></pre><blockquote>
<p>注意
上面定义的函数<code>swapTwoValues</code>是受<code>swap</code>函数启发而实现的。<code>swap</code>函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似<code>swapTwoValues</code>函数的功能，你可以使用已存在的交换函数<code>swap</code>函数。</p>
</code></pre>
<blockquote>
<p>注意<br>上面定义的函数<code>swapTwoValues</code>是受<code>swap</code>函数启发而实现的。<code>swap</code>函数存在于 Swift 标准库，并可以在其它类中任意使用。如果你在自己代码中需要类似<code>swapTwoValues</code>函数的功能，你可以使用已存在的交换函数<code>swap</code>函数。</p>
</blockquote>
<p><a name="type_parameters"></a></p>
<h2 id="-">类型参数</h2>
@ -679,16 +682,14 @@ swapTwoValues(&amp;someString, &amp;anotherString)
<p>在简单的情况下，泛型函数或泛型类型需要指定一个占位类型（如上面的<code>swapTwoValues</code>泛型函数，或一个存储单一类型的泛型集，如数组），通常用一单个字母<code>T</code>来命名类型参数。不过，你可以使用任何有效的标识符来作为类型参数名。</p>
<p>如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为<code>KeyType</code>和<code>ValueType</code>，用来记住它们在你的泛型代码中的作用。</p>
<blockquote>
<p>注意
请始终使用大写字母开头的驼峰式命名法（例如<code>T</code>和<code>KeyType</code>）来给类型参数命名，以表明它们是类型的占位符，而非类型值。</p>
<p>注意<br>请始终使用大写字母开头的驼峰式命名法（例如<code>T</code>和<code>KeyType</code>）来给类型参数命名，以表明它们是类型的占位符，而非类型值。</p>
</blockquote>
<p><a name="generic_types"></a></p>
<h2 id="-">泛型类型</h2>
<p>通常在泛型函数中，Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同<code>Array</code>和<code>Dictionary</code>的用法。</p>
<p>这部分向你展示如何写一个泛型集类型--<code>Stack</code>（栈）。一个栈是一系列值域的集合，和<code>Array</code>（数组）类似，但其是一个比 Swift 的<code>Array</code>类型更多限制的集合。一个数组可以允许其里面任何位置的插入/删除操作，而栈，只允许在集合的末端添加新的项（如同<em>push</em>一个新值进栈）。同样的一个栈也只能从末端移除项（如同<em>pop</em>一个值出栈）。</p>
<blockquote>
<p>注意
栈的概念已被<code>UINavigationController</code>类使用来模拟试图控制器的导航结构。你通过调用<code>UINavigationController</code>的<code>pushViewController:animated:</code>方法来为导航栈添加（add）新的试图控制器；而通过<code>popViewControllerAnimated:</code>的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的<code>后进先出</code>方式来管理集合，堆栈都是最实用的模型。</p>
<p>注意<br>栈的概念已被<code>UINavigationController</code>类使用来模拟试图控制器的导航结构。你通过调用<code>UINavigationController</code>的<code>pushViewController:animated:</code>方法来为导航栈添加（add）新的试图控制器；而通过<code>popViewControllerAnimated:</code>的方法来从导航栈中移除（pop）某个试图控制器。每当你需要一个严格的<code>后进先出</code>方式来管理集合，堆栈都是最实用的模型。</p>
</blockquote>
<p>下图展示了一个栈的压栈(push)/出栈(pop)的行为：</p>
<p>![此处输入图片的描述][2]</p>
@ -700,7 +701,7 @@ swapTwoValues(&amp;someString, &amp;anotherString)
<li>移除掉一个值后，现在栈又重新只有三个值。</li>
</ol>
<p>这里展示了如何写一个非泛型版本的栈，<code>Int</code>值型的栈：</p>
<pre><code>struct IntStack {
<pre><code class="lang-swift">struct IntStack {
var items = Int[]()
mutating func push(item: Int) {
items.append(item)
@ -709,10 +710,11 @@ swapTwoValues(&amp;someString, &amp;anotherString)
return items.removeLast()
}
}
</code></pre><p>这个结构体在栈中使用一个<code>Array</code>性质的<code>items</code>存储值。<code>Stack</code>提供两个方法：<code>push</code>和<code>pop</code>，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为它们需要修改（或<em>转换</em>）结构体的<code>items</code>数组。</p>
</code></pre>
<p>这个结构体在栈中使用一个<code>Array</code>性质的<code>items</code>存储值。<code>Stack</code>提供两个方法：<code>push</code>和<code>pop</code>，从栈中压进一个值和移除一个值。这些方法标记为可变的，因为它们需要修改（或<em>转换</em>）结构体的<code>items</code>数组。</p>
<p>上面所展现的<code>IntStack</code>类型只能用于<code>Int</code>值，不过，其对于定义一个泛型<code>Stack</code>类（可以处理<em>任何</em>类型值的栈）是非常有用的。</p>
<p>这里是一个相同代码的泛型版本：</p>
<pre><code>struct Stack&lt;T&gt; {
<pre><code class="lang-swift">struct Stack&lt;T&gt; {
var items = T[]()
mutating func push(item: T) {
items.append(item)
@ -721,7 +723,8 @@ swapTwoValues(&amp;someString, &amp;anotherString)
return items.removeLast()
}
}
</code></pre><p>注意到<code>Stack</code>的泛型版本基本上和非泛型版本相同，但是泛型版本的占位类型参数为T代替了实际<code>Int</code>类型。这种类型参数包含在一对尖括号里（<code>&lt;T&gt;</code>），紧随在结构体名字后面。</p>
</code></pre>
<p>注意到<code>Stack</code>的泛型版本基本上和非泛型版本相同，但是泛型版本的占位类型参数为T代替了实际<code>Int</code>类型。这种类型参数包含在一对尖括号里（<code>&lt;T&gt;</code>），紧随在结构体名字后面。</p>
<p><code>T</code>定义了一个名为“某种类型T”的节点提供给后来用。这种将来类型可以在结构体的定义里任何地方表示为“T”。在这种情况下，<code>T</code>在如下三个地方被用作节点：</p>
<ul>
<li>创建一个名为<code>items</code>的属性，使用空的T类型值数组对其进行初始化；</li>
@ -729,18 +732,20 @@ swapTwoValues(&amp;someString, &amp;anotherString)
<li>指定一个<code>pop</code>方法的返回值，该返回值将是一个T类型值。</li>
</ul>
<p>当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个<code>Stack</code>实例，同创建<code>Array</code>和<code>Dictionary</code>一样：</p>
<pre><code>var stackOfStrings = Stack&lt;String&gt;()
<pre><code class="lang-swift">var stackOfStrings = Stack&lt;String&gt;()
stackOfStrings.push(&quot;uno&quot;)
stackOfStrings.push(&quot;dos&quot;)
stackOfStrings.push(&quot;tres&quot;)
stackOfStrings.push(&quot;cuatro&quot;)
// 现在栈已经有4个string了
</code></pre><p>下图将展示<code>stackOfStrings</code>如何<code>push</code>这四个值进栈的过程：</p>
</code></pre>
<p>下图将展示<code>stackOfStrings</code>如何<code>push</code>这四个值进栈的过程：</p>
<p>![此处输入图片的描述][3]</p>
<p>从栈中<code>pop</code>并移除值&quot;cuatro&quot;：</p>
<pre><code>let fromTheTop = stackOfStrings.pop()
<pre><code class="lang-swift">let fromTheTop = stackOfStrings.pop()
// fromTheTop is equal to &quot;cuatro&quot;, and the stack now contains 3 strings
</code></pre><p>下图展示了如何从栈中pop一个值的过程：
</code></pre>
<p>下图展示了如何从栈中pop一个值的过程：
![此处输入图片的描述][4]</p>
<p>由于<code>Stack</code>是泛型类型，所以在 Swift 中其可以用来创建任何有效类型的栈，这种方式如同<code>Array</code>和<code>Dictionary</code>。</p>
<p><a name="type_constraints"></a></p>
@ -751,13 +756,14 @@ stackOfStrings.push(&quot;cuatro&quot;)
<p>当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如<code>可哈希</code>具有的类型特征是根据它们概念特征来界定的，而不是它们的直接类型特征。</p>
<h3 id="-">类型约束语法</h3>
<p>你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）：</p>
<pre><code>func someFunction&lt;T: SomeClass, U: SomeProtocol&gt;(someT: T, someU: U) {
<pre><code class="lang-swift">func someFunction&lt;T: SomeClass, U: SomeProtocol&gt;(someT: T, someU: U) {
// function body goes here
}
</code></pre><p>上面这个假定函数有两个类型参数。第一个类型参数<code>T</code>，有一个需要<code>T</code>必须是<code>SomeClass</code>子类的类型约束；第二个类型参数<code>U</code>，有一个需要<code>U</code>必须遵循<code>SomeProtocol</code>协议的类型约束。</p>
</code></pre>
<p>上面这个假定函数有两个类型参数。第一个类型参数<code>T</code>，有一个需要<code>T</code>必须是<code>SomeClass</code>子类的类型约束；第二个类型参数<code>U</code>，有一个需要<code>U</code>必须遵循<code>SomeProtocol</code>协议的类型约束。</p>
<h3 id="-">类型约束行为</h3>
<p>这里有个名为<code>findStringIndex</code>的非泛型函数，该函数功能是去查找包含一给定<code>String</code>值的数组。若查找到匹配的字符串，<code>findStringIndex</code>函数返回该字符串在数组中的索引值（<code>Int</code>），反之则返回<code>nil</code>：</p>
<pre><code>func findStringIndex(array: String[], valueToFind: String) -&gt; Int? {
<pre><code class="lang-swift">func findStringIndex(array: String[], valueToFind: String) -&gt; Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
@ -765,15 +771,17 @@ stackOfStrings.push(&quot;cuatro&quot;)
}
return nil
}
</code></pre><p><code>findStringIndex</code>函数可以作用于查找一字符串数组中的某个字符串:</p>
<pre><code>let strings = [&quot;cat&quot;, &quot;dog&quot;, &quot;llama&quot;, &quot;parakeet&quot;, &quot;terrapin&quot;]
</code></pre>
<p><code>findStringIndex</code>函数可以作用于查找一字符串数组中的某个字符串:</p>
<pre><code class="lang-swift">let strings = [&quot;cat&quot;, &quot;dog&quot;, &quot;llama&quot;, &quot;parakeet&quot;, &quot;terrapin&quot;]
if let foundIndex = findStringIndex(strings, &quot;llama&quot;) {
println(&quot;The index of llama is \(foundIndex)&quot;)
}
// 输出 &quot;The index of llama is 2&quot;
</code></pre><p>如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数<code>findIndex</code>，用某个类型<code>T</code>值替换掉提到的字符串。</p>
</code></pre>
<p>如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数<code>findIndex</code>，用某个类型<code>T</code>值替换掉提到的字符串。</p>
<p>这里展示如何写一个你或许期望的<code>findStringIndex</code>的泛型版本<code>findIndex</code>。请注意这个函数仍然返回<code>Int</code>，是不是有点迷惑呢，而不是泛型类型?那是因为函数返回的是一个可选的索引数，而不是从数组中得到的一个可选值。需要提醒的是，这个函数不会编译，原因在例子后面会说明：</p>
<pre><code>func findIndex&lt;T&gt;(array: T[], valueToFind: T) -&gt; Int? {
<pre><code class="lang-swift">func findIndex&lt;T&gt;(array: T[], valueToFind: T) -&gt; Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
@ -781,10 +789,11 @@ if let foundIndex = findStringIndex(strings, &quot;llama&quot;) {
}
return nil
}
</code></pre><p>上面所写的函数不会编译。这个问题的位置在等式的检查上，<code>“if value == valueToFind”</code>。不是所有的 Swift 中的类型都可以用等式符（==）进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么 Swift 没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型<code>T</code>，当你试图编译这部分代码时估计会出现相应的错误。</p>
</code></pre>
<p>上面所写的函数不会编译。这个问题的位置在等式的检查上，<code>“if value == valueToFind”</code>。不是所有的 Swift 中的类型都可以用等式符（==）进行比较。例如，如果你创建一个你自己的类或结构体来表示一个复杂的数据模型，那么 Swift 没法猜到对于这个类或结构体而言“等于”的意思。正因如此，这部分代码不能可能保证工作于每个可能的类型<code>T</code>，当你试图编译这部分代码时估计会出现相应的错误。</p>
<p>不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个<code>Equatable</code>协议，该协议要求任何遵循的类型实现等式符（==）和不等符（!=）对任何两个该类型进行比较。所有的 Swift 标准类型自动支持<code>Equatable</code>协议。</p>
<p>任何<code>Equatable</code>类型都可以安全的使用在<code>findIndex</code>函数中，因为其保证支持等式操作。为了说明这个事实，当你定义一个函数时，你可以写一个<code>Equatable</code>类型约束作为类型参数定义的一部分：</p>
<pre><code>func findIndex&lt;T: Equatable&gt;(array: T[], valueToFind: T) -&gt; Int? {
<pre><code class="lang-swift">func findIndex&lt;T: Equatable&gt;(array: T[], valueToFind: T) -&gt; Int? {
for (index, value) in enumerate(array) {
if value == valueToFind {
return index
@ -792,24 +801,27 @@ if let foundIndex = findStringIndex(strings, &quot;llama&quot;) {
}
return nil
}
</code></pre><p><code>findIndex</code>中这个单个类型参数写做：<code>T: Equatable</code>，也就意味着“任何T类型都遵循<code>Equatable</code>协议”。</p>
</code></pre>
<p><code>findIndex</code>中这个单个类型参数写做：<code>T: Equatable</code>，也就意味着“任何T类型都遵循<code>Equatable</code>协议”。</p>
<p><code>findIndex</code>函数现在则可以成功的编译过，并且作用于任何遵循<code>Equatable</code>的类型，如<code>Double</code>或<code>String</code>:</p>
<pre><code>let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
<pre><code class="lang-swift">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([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea&quot;], &quot;Andrea&quot;)
// stringIndex is an optional Int containing a value of 2
</code></pre><p><a name="associated_types"></a></p>
</code></pre>
<p><a name="associated_types"></a></p>
<h2 id="-">关联类型</h2>
<p>当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型给定作用于协议部分的类型一个节点名（或<em>别名</em>）。作用于关联类型上实际类型是不需要指定的，直到该协议接受。关联类型被指定为<code>typealias</code>关键字。</p>
<h3 id="-">关联类型行为</h3>
<p>这里是一个<code>Container</code>协议的例子，定义了一个ItemType关联类型：</p>
<pre><code>protocol Container {
<pre><code class="lang-swift">protocol Container {
typealias ItemType
mutating func append(item: ItemType)
var count: Int { get }
subscript(i: Int) -&gt; ItemType { get }
}
</code></pre><p><code>Container</code>协议定义了三个任何容器必须支持的兼容要求：</p>
</code></pre>
<p><code>Container</code>协议定义了三个任何容器必须支持的兼容要求：</p>
<ul>
<li>必须可能通过<code>append</code>方法添加一个新item到容器里；</li>
<li>必须可能通过使用<code>count</code>属性获取容器里items的数量，并返回一个<code>Int</code>值；</li>
@ -820,7 +832,7 @@ let stringIndex = findIndex([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea
<p>为了定义这三个条件，<code>Container</code>协议需要一个方法指定容器里的元素将会保留，而不需要知道特定容器的类型。<code>Container</code>协议需要指定任何通过<code>append</code>方法添加到容器里的值和容器里元素是相同类型，并且通过容器下标返回的容器元素类型的值的类型是相同类型。</p>
<p>为了达到此目的，<code>Container</code>协议声明了一个ItemType的关联类型，写作<code>typealias ItemType</code>。The protocol does not define what ItemType is an alias for—that information is left for any conforming type to provide（这个协议不会定义<code>ItemType</code>是遵循类型所提供的何种信息的别名）。尽管如此，<code>ItemType</code>别名支持一种方法识别在一个容器里的items类型，以及定义一种使用在<code>append</code>方法和下标中的类型，以便保证任何期望的<code>Container</code>的行为是强制性的。</p>
<p>这里是一个早前IntStack类型的非泛型版本，适用于遵循Container协议：</p>
<pre><code>struct IntStack: Container {
<pre><code class="lang-swift">struct IntStack: Container {
// original IntStack implementation
var items = Int[]()
mutating func push(item: Int) {
@ -841,11 +853,12 @@ let stringIndex = findIndex([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea
return items[i]
}
}
</code></pre><p><code>IntStack</code>类型实现了<code>Container</code>协议的所有三个要求，在<code>IntStack</code>类型的每个包含部分的功能都满足这些要求。</p>
</code></pre>
<p><code>IntStack</code>类型实现了<code>Container</code>协议的所有三个要求，在<code>IntStack</code>类型的每个包含部分的功能都满足这些要求。</p>
<p>此外，<code>IntStack</code>指定了<code>Container</code>的实现，适用的ItemType被用作<code>Int</code>类型。对于这个<code>Container</code>协议实现而言，定义 <code>typealias ItemType = Int</code>，将抽象的<code>ItemType</code>类型转换为具体的<code>Int</code>类型。</p>
<p>感谢Swift类型参考，你不用在<code>IntStack</code>定义部分声明一个具体的<code>Int</code>的<code>ItemType</code>。由于<code>IntStack</code>遵循<code>Container</code>协议的所有要求，只要通过简单的查找<code>append</code>方法的item参数类型和下标返回的类型，Swift就可以推断出合适的<code>ItemType</code>来使用。确实，如果上面的代码中你删除了 <code>typealias ItemType = Int</code>这一行，一切仍旧可以工作，因为它清楚的知道ItemType使用的是何种类型。</p>
<p>你也可以生成遵循<code>Container</code>协议的泛型<code>Stack</code>类型：</p>
<pre><code>struct Stack&lt;T&gt;: Container {
<pre><code class="lang-swift">struct Stack&lt;T&gt;: Container {
// original Stack&lt;T&gt; implementation
var items = T[]()
mutating func push(item: T) {
@ -865,19 +878,21 @@ let stringIndex = findIndex([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea
return items[i]
}
}
</code></pre><p>这个时候，占位类型参数<code>T</code>被用作<code>append</code>方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的<code>ItemType</code>的<code>T</code>的合适类型。</p>
</code></pre>
<p>这个时候，占位类型参数<code>T</code>被用作<code>append</code>方法的item参数和下标的返回类型。Swift 因此可以推断出被用作这个特定容器的<code>ItemType</code>的<code>T</code>的合适类型。</p>
<h3 id="-">扩展一个存在的类型为一指定关联类型</h3>
<p>在[使用扩展来添加协议兼容性][6]中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。</p>
<p>Swift的<code>Array</code>已经提供<code>append</code>方法，一个<code>count</code>属性和通过下标来查找一个自己的元素。这三个功能都达到<code>Container</code>协议的要求。也就意味着你可以扩展<code>Array</code>去遵循<code>Container</code>协议，只要通过简单声明<code>Array</code>适用于该协议而已。如何实践这样一个空扩展，在[使用扩展来声明协议的采纳][7]中有描述这样一个实现一个空扩展的行为：</p>
<pre><code>extension Array: Container {}
</code></pre><p>如同上面的泛型<code>Stack</code>类型一样，<code>Array的append</code>方法和下标保证<code>Swift</code>可以推断出<code>ItemType</code>所使用的适用的类型。定义了这个扩展后，你可以将任何<code>Array</code>当作<code>Container</code>来使用。</p>
<pre><code class="lang-swift">extension Array: Container {}
</code></pre>
<p>如同上面的泛型<code>Stack</code>类型一样，<code>Array的append</code>方法和下标保证<code>Swift</code>可以推断出<code>ItemType</code>所使用的适用的类型。定义了这个扩展后，你可以将任何<code>Array</code>当作<code>Container</code>来使用。</p>
<p><a name="where_clauses"></a></p>
<h2 id="where-">Where 语句</h2>
<p>[类型约束][8]中描述的类型约束确保你定义关于类型参数的需求和一泛型函数或类型有关联。</p>
<p>对于关联类型的定义需求也是非常有用的。你可以通过这样去定义<em>where语句</em>作为一个类型参数队列的一部分。一个<code>where</code>语句使你能够要求一个关联类型遵循一个特定的协议，以及（或）那个特定的类型参数和关联类型可以是相同的。你可写一个<code>where</code>语句，通过紧随放置<code>where</code>关键字在类型参数队列后面，其后跟着一个或者多个针对关联类型的约束，以及（或）一个或多个类型和关联类型的等于关系。</p>
<p>下面的列子定义了一个名为<code>allItemsMatch</code>的泛型函数，用来检查是否两个<code>Container</code>单例包含具有相同顺序的相同元素。如果匹配到所有的元素，那么返回一个为<code>true</code>的<code>Boolean</code>值，反之，则相反。</p>
<p>这两个容器可以被检查出是否是相同类型的容器（虽然它们可以是），但它们确实拥有相同类型的元素。这个需求通过一个类型约束和<code>where</code>语句结合来表示：</p>
<pre><code>func allItemsMatch&lt;
<pre><code class="lang-swift">func allItemsMatch&lt;
C1: Container, C2: Container
where C1.ItemType == C2.ItemType, C1.ItemType: Equatable&gt;
(someContainer: C1, anotherContainer: C2) -&gt; Bool {
@ -898,7 +913,8 @@ let stringIndex = findIndex([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea
return true
}
</code></pre><p>这个函数用了两个参数：<code>someContainer</code>和<code>anotherContainer</code>。<code>someContainer</code>参数是类型<code>C1</code>，<code>anotherContainer</code>参数是类型<code>C2</code>。<code>C1</code>和<code>C2</code>是容器的两个占位类型参数，决定了这个函数何时被调用。</p>
</code></pre>
<p>这个函数用了两个参数：<code>someContainer</code>和<code>anotherContainer</code>。<code>someContainer</code>参数是类型<code>C1</code>，<code>anotherContainer</code>参数是类型<code>C2</code>。<code>C1</code>和<code>C2</code>是容器的两个占位类型参数，决定了这个函数何时被调用。</p>
<p>这个函数的类型参数列紧随在两个类型参数需求的后面：</p>
<ul>
<li><code>C1</code>必须遵循<code>Container</code>协议 (写作 <code>C1: Container</code>)。</li>
@ -918,7 +934,7 @@ let stringIndex = findIndex([&quot;Mike&quot;, &quot;Malcolm&quot;, &quot;Andrea
<p>检查完之后，函数通过<code>for-in</code>循环和半闭区间操作（..）来迭代<code>someContainer</code>中的所有元素。对于每个元素，函数检查是否<code>someContainer</code>中的元素不等于对应的<code>anotherContainer</code>中的元素，如果这两个元素不等，则这两个容器不匹配，返回<code>false</code>。</p>
<p>如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回<code>true</code>。</p>
<p>这里演示了allItemsMatch函数运算的过程：</p>
<pre><code>var stackOfStrings = Stack&lt;String&gt;()
<pre><code class="lang-swift">var stackOfStrings = Stack&lt;String&gt;()
stackOfStrings.push(&quot;uno&quot;)
stackOfStrings.push(&quot;dos&quot;)
stackOfStrings.push(&quot;tres&quot;)
@ -931,7 +947,8 @@ if allItemsMatch(stackOfStrings, arrayOfStrings) {
println(&quot;Not all items match.&quot;)
}
// 输出 &quot;All items match.&quot;
</code></pre><p> 上面的例子创建一个<code>Stack</code>单例来存储<code>String</code>，然后压了三个字符串进栈。这个例子也创建了一个<code>Array</code>单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但它们都遵循<code>Container</code>协议，而且它们都包含同样的类型值。你因此可以调用<code>allItemsMatch</code>函数，用这两个容器作为它的参数。在上面的例子中，<code>allItemsMatch</code>函数正确的显示了所有的这两个容器的<code>items</code>匹配。</p>
</code></pre>
<p> 上面的例子创建一个<code>Stack</code>单例来存储<code>String</code>，然后压了三个字符串进栈。这个例子也创建了一个<code>Array</code>单例，并初始化包含三个同栈里一样的原始字符串。即便栈和数组否是不同的类型，但它们都遵循<code>Container</code>协议，而且它们都包含同样的类型值。你因此可以调用<code>allItemsMatch</code>函数，用这两个容器作为它的参数。在上面的例子中，<code>allItemsMatch</code>函数正确的显示了所有的这两个容器的<code>items</code>匹配。</p>
</section>

15
chapter2/23_Advanced_Operators.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2.23" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2.23" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,11 +587,10 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_78">
<section class="normal" id="section-gitbook_555">
<blockquote>
<p>翻译：xielingwang</p>
<p>校对：numbbbbb</p>
<p>翻译：xielingwang<br>校对：numbbbbb </p>
</blockquote>
<h1 id="-">高级运算符</h1>
<hr>
@ -776,8 +775,7 @@ let y = x &amp;/ 0
<p>计算结果为 4。</p>
<p>查阅Swift运算符的优先级和结合性的完整列表，请看<a href="../chapter3/04_Expressions.html">表达式</a>。</p>
<blockquote>
<p>注意：</p>
<p>Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。</p>
<p>注意：<br>Swift的运算符较C语言和Objective-C来得更简单和保守，这意味着跟基于C的语言可能不一样。所以，在移植已有代码到Swift时，注意去确保代码按你想的那样去执行。</p>
</blockquote>
<p><a name="operator_functions"></a></p>
<h2 id="-">运算符函数</h2>
@ -841,8 +839,7 @@ let afterIncrement = ++toIncrement
// afterIncrement 现在也是 (4.0, 5.0)
</code></pre>
<blockquote>
<p>注意：</p>
<p>默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 <code>a？b：c</code> 也是不可重载。</p>
<p>注意：<br>默认的赋值符是不可重载的。只有组合赋值符可以重载。三目条件运算符 <code>a？b：c</code> 也是不可重载。</p>
</blockquote>
<h3 id="-">比较运算符</h3>
<p>Swift无所知道自定义类型是否相等或不等，因为等于或者不等于由你的代码说了算了。所以自定义的类和结构要使用比较符<code>==</code>或<code>!=</code>就需要重载。</p>
@ -895,7 +892,7 @@ let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此时的值为 (4.0, -2.0)
</code></pre>
<p>这个运算符把两个向量的<code>x</code>相加，把向量的<code>y</code>相减。因为它实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(<code>left</code>和<code>140</code>)。查阅完整的Swift默认结合性和优先级的设置，请移步<a href="../chapter3/04_Expressions.html">表达式</a>;</p>
<p>这个运算符把两个向量的<code>x</code>相加，把向量的<code>y</code>相减。因为他实际是属于加减运算，所以让它保持了和加法一样的结合性和优先级(<code>left</code>和<code>140</code>)。查阅完整的Swift默认结合性和优先级的设置，请移步<a href="../chapter3/04_Expressions.html">表达式</a>;</p>
</section>

4
chapter2/chapter2.html
View File

@ -46,7 +46,7 @@
<div class="book" data-level="2" data-basepath=".." data-revision="1402750255397">
<div class="book" data-level="2" data-basepath=".." data-revision="1402759431779">
<div class="book-header">
<!-- Actions Left -->
<a href="#" class="btn pull-left toggle-summary" aria-label="Toggle summary"><i class="fa fa-align-justify"></i></a>
@ -587,7 +587,7 @@
<div class="page-inner">
<section class="normal" id="section-gitbook_80">
<section class="normal" id="section-gitbook_554">
<h1 id="swift-">Swift 教程</h1>
<p>本章介绍了 Swift 的各种特性及其使用方法，是全书的核心部分。</p>