make gitbook
This commit is contained in:
numbbbbb
@ -46,7 +46,7 @@
|
||||
|
||||
|
||||
|
||||
<div class="book" data-level="2.16" data-basepath=".." data-revision="1402565541342">
|
||||
<div class="book" data-level="2.16" data-basepath=".." data-revision="1402617910282">
|
||||
<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>
|
||||
@ -599,10 +599,10 @@
|
||||
<ul>
|
||||
<li><a href="#how_arc_works">自动引用计数的工作机制</a></li>
|
||||
<li><a href="#arc_in_action">自动引用计数实践</a></li>
|
||||
<li><a href="#strong_reference_cycles_between_class_instances">类实例间的强引用环</a></li>
|
||||
<li><a href="#resolving_strong_reference_cycles_between_class_instances">类实例间的强引用环分解</a></li>
|
||||
<li><a href="#strong_reference_cycles_for_closures">闭包的强引用环</a></li>
|
||||
<li><a href="#resolving_strong_reference_cycles_for_closures">闭包的强引用环分解</a></li>
|
||||
<li><a href="#strong_reference_cycles_between_class_instances">类实例之间的循环强引用</a></li>
|
||||
<li><a href="#resolving_strong_reference_cycles_between_class_instances">解决实例之间的循环强引用</a></li>
|
||||
<li><a href="#strong_reference_cycles_for_closures">闭包引起的循环强引用</a></li>
|
||||
<li><a href="#resolving_strong_reference_cycles_for_closures">解决闭包引起的循环强引用</a></li>
|
||||
</ul>
|
||||
<p>Swift 使用自动引用计数（ARC）这一机制来跟踪和管理你的应用程序的内存。通常情况下，Swift 的内存管理机制会一直起着作用，你无须自己来考虑内存的管理。ARC 会在类的实例不再被使用时，自动释放其占用的内存。</p>
|
||||
<p>然而，在少数情况下，ARC 为了能帮助你管理内存，需要更多的关于你的代码之间关系的信息。本章描述了这些情况，并且为你示范怎样启用 ARC 来管理你的应用程序的内存。</p>
|
||||
@ -617,7 +617,7 @@
|
||||
<p>为了确保使用中的实例不会被销毁，ARC 会跟踪和计算每一个实例正在被多少属性，常量和变量所引用。哪怕实例的引用数为一，ARC都不会销毁这个实例。</p>
|
||||
<p>为了使之成为可能，无论你将实例赋值给属性，常量或者是变量，属性，常量或者变量，都会对此实例创建强引用。之所以称之为强引用，是因为它会将实例牢牢的保持住，只要强引用还在，实例是不允许被销毁的。</p>
|
||||
<p><a name="arc_in_action"></a></p>
|
||||
<h2 id="-">自动引用计数实战</h2>
|
||||
<h2 id="-">自动引用计数实践</h2>
|
||||
<p>下面的例子展示了自动引用计数的工作机制。例子以一个简单的<code>Person</code>类开始，并定义了一个叫<code>name</code>的常量属性：</p>
|
||||
<pre><code> class Person {
|
||||
let name: String
|
||||
@ -646,8 +646,8 @@
|
||||
reference3 = reference1
|
||||
</code></pre><p>现在这个<code>Person</code>实例已经有三个强引用了。</p>
|
||||
<p>如果你通过给两个变量赋值<code>nil</code>的方式断开两个强引用（）包括最先的那个强引用），只留下一个强引用，<code>Person</code>实例不会被销毁：</p>
|
||||
<pre><code>reference2 = reference1
|
||||
reference3 = reference1
|
||||
<pre><code>reference2 = nil
|
||||
reference3 = nil
|
||||
</code></pre><p>ARC 会在第三个，也即最后一个强引用被断开的时候，销毁<code>Person</code>实例，这也意味着你不再使用这个<code>Person</code>实例：</p>
|
||||
<pre><code>reference3 = nil
|
||||
// prints "John Appleseed is being deinitialized"
|
||||
@ -655,7 +655,7 @@ reference3 = reference1
|
||||
<h2 id="-">类实例之间的循环强引用</h2>
|
||||
<p>在上面的例子中，ARC 会跟踪你所新创建的<code>Person</code>实例的引用数量，并且会在<code>Person</code>实例不再被需要时销毁它。</p>
|
||||
<p>然而，我们可能会写出这样的代码，一个类永远不会有0个强引用。这种情况发生在两个类实例互相保持对方的强引用，并让对方不被销毁。这就是所谓的循环强引用。</p>
|
||||
<p>你可以通过定义类之间的关系为弱引用或者无主引用，以此替代强引用，从而解决循环强引用的问题。具体的过程在<a href="#1">解决类实例之间的循环强引用</a>中有描述。不管怎样，在你学习怎样解决循环强引用之前，很有必要了解一下它是怎样产生的。</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 {
|
||||
let name: String
|
||||
@ -679,7 +679,7 @@ var number73: Apartment?
|
||||
</code></pre><p>现在你可以创建特定的<code>Person</code>和<code>Apartment</code>实例并将类实例赋值给<code>john</code>和<code>number73</code>变量：</p>
|
||||
<pre><code>john = Person(name: "John Appleseed")
|
||||
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
|
||||
@ -694,7 +694,7 @@ number73 = nil
|
||||
<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>
|
||||
<p><a name="resolving_strong_reference_cycles_between_class_instances"></a></p>
|
||||
<h2 id="-a-name-1-a-"><a name="1">解决实例之间的循环强引用</a></h2>
|
||||
<h2 id="-">解决实例之间的循环强引用</h2>
|
||||
<p>Swift 提供了两种办法用来解决你在使用类的属性时所遇到的循环强引用问题：弱引用（weak reference）和无主引用（unowned reference）。</p>
|
||||
<p>弱引用和无主引用允许循环引用中的一个实例引用另外一个实例而不保持强引用。这样实例能够互相引用而不产生循环强引用。</p>
|
||||
<p>对于生命周期中会变为<code>nil</code>的实例使用弱引用。相反的，对于初始化赋值后再也不会被赋值为<code>nil</code>的实例，使用无主引用。</p>
|
||||
@ -702,8 +702,8 @@ number73 = nil
|
||||
<p>弱引用不会牢牢保持住引用的实例，并且不会阻止 ARC 销毁被引用的实例。这种行为阻止了引用变为循环强引用。声明属性或者变量时，在前面加上<code>weak</code>关键字表明这是一个弱引用。</p>
|
||||
<p>在实例的生命周期中，如果某些时候引用没有值，那么弱引用可以阻止循环强引用。如果引用总是有值，则可以使用无主引用，在<a href="#2">无主引用</a>中有描述。在上面<code>Apartment</code>的例子中，一个公寓的生命周期中，有时是没有“居民”的，因此适合使用弱引用来解决循环强引用。</p>
|
||||
<blockquote>
|
||||
<p>注意:</p>
|
||||
<p>弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。</p>
|
||||
<p>注意:
|
||||
弱引用必须被声明为变量，表明其值能在运行时被修改。弱引用不能被声明为常量。</p>
|
||||
</blockquote>
|
||||
<p>因为弱引用可以没有值，你必须将每一个弱引用声明为可选类型。可选类型是在 Swift 语言中推荐的用来表示可能没有值的类型。</p>
|
||||
<p>因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为<code>nil</code>。你可以像其他可选值一样，检查弱引用的值是否存在，你永远也不会遇到被销毁了而不存在的实例。</p>
|
||||
@ -743,7 +743,8 @@ number73!.tenant = john
|
||||
<pre><code>number73 = nil
|
||||
// prints "Apartment #73 is being deinitialized"
|
||||
</code></pre><p>上面的两段代码展示了变量<code>john</code>和<code>number73</code>在被赋值为<code>nil</code>后，<code>Person</code>实例和<code>Apartment</code>实例的析构函数都打印出“销毁”的信息。这证明了引用循环被打破了。</p>
|
||||
<h3 id="-a-name-2-a-"><a name="2">无主引用</a></h3>
|
||||
<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>
|
||||
@ -788,11 +789,11 @@ john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)
|
||||
// prints "John Appleseed is being deinitialized"
|
||||
// prints "Card #1234567890123456 is being deinitialized"
|
||||
</code></pre><p>最后的代码展示了在<code>john</code>变量被设为<code>nil</code>后<code>Customer</code>实例和<code>CreditCard</code>实例的构造函数都打印出了“销毁”的信息。</p>
|
||||
<h3 id="-">无主引用以及显式展开的可选属性</h3>
|
||||
<h3 id="-">无主引用以及隐式解析可选属性</h3>
|
||||
<p>上面弱引用和无主引用的例子涵盖了两种常用的需要打破循环强引用的场景。</p>
|
||||
<p><code>Person</code>和<code>Apartment</code>的例子展示了两个属性的值都允许为<code>nil</code>，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。</p>
|
||||
<p><code>Customer</code>和<code>CreditCard</code>的例子展示了一个属性的值允许为<code>nil</code>，而另一个属性的值不允许为<code>nil</code>，并会潜在的产生循环强引用。这种场景最适合通过无主引用来解决。</p>
|
||||
<p>然而，存在着第三种场景，在这种场景中，两个属性都必须有值，并且初始化完成后不能为<code>nil</code>。在这种场景中，需要一个类使用无主属性，而另外一个类使用显示展开的可选属性。</p>
|
||||
<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 {
|
||||
@ -813,14 +814,14 @@ class City {
|
||||
}
|
||||
}
|
||||
</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>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: "Canada", capitalName: "Ottawa")
|
||||
println("\(country.name)'s capital city is called \(country.capitalCity.name)")
|
||||
// prints "Canada's capital city is called Ottawa"
|
||||
</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>
|
||||
@ -870,40 +871,41 @@ println(paragraph!.asHTML())
|
||||
</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>
|
||||
<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>虽然闭包多次使用了<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>
|
||||
<p><a name="resolving_strong_reference_cycles_for_closures"></a></p>
|
||||
<h2 id="-">解决闭包引起的循环强引用</h2>
|
||||
<p>在定义闭包时同时定义占有列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。占有列表定义了闭包体内占有一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个占有的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。</p>
|
||||
<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>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>
|
||||
<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) -> String = {
|
||||
[unowned self] (index: Int, stringToProcess: String) -> String in
|
||||
// closure body goes here
|
||||
}
|
||||
</code></pre><p>如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以占有列表放在闭包开始的地方，跟着是关键字<code>in</code>：</p>
|
||||
</code></pre><p>如果闭包没有指定参数列表或者返回类型，则可以通过上下文推断，那么可以捕获列表放在闭包开始的地方，跟着是关键字<code>in</code>：</p>
|
||||
<pre><code>@lazy var someClosure: () -> String = {
|
||||
[unowned self] in
|
||||
// closure body goes here
|
||||
}
|
||||
</code></pre><h3 id="-">弱引用和无主引用</h3>
|
||||
<p>当闭包和占有的实例总是互相引用时并且总是同时销毁时，将闭包内的占有定义为无主引用。</p>
|
||||
<p>相反的，当占有引用有时可能会是<code>nil</code>时，将闭包内的占有定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为<code>nil</code>。这使我们可以在闭包内检查他们是否存在。</p>
|
||||
<p>当闭包和捕获的实例总是互相引用时并且总是同时销毁时，将闭包内的捕获定义为无主引用。</p>
|
||||
<p>相反的，当捕获引用有时可能会是<code>nil</code>时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为<code>nil</code>。这使我们可以在闭包内检查他们是否存在。</p>
|
||||
<blockquote>
|
||||
<p>注意:</p>
|
||||
<p>如果占有的引用绝对不会置为<code>nil</code>，应该用无主引用，而不是弱引用。</p>
|
||||
<p>如果捕获的引用绝对不会置为<code>nil</code>，应该用无主引用，而不是弱引用。</p>
|
||||
</blockquote>
|
||||
<p>前面的<code>HTMLElement</code>例子中，无主引用是正确的解决循环强引用的方法。这样这样编写<code>HTMLElement</code>类来避免循环强引用：</p>
|
||||
<p>前面的<code>HTMLElement</code>例子中，无主引用是正确的解决循环强引用的方法。这样编写<code>HTMLElement</code>类来避免循环强引用：</p>
|
||||
<pre><code>class HTMLElement {
|
||||
|
||||
let name: String
|
||||
@ -928,14 +930,14 @@ 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: "p", text: "hello, world")
|
||||
println(paragraph!.asHTML())
|
||||
// prints "<p>hello, world</p>"
|
||||
</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>
|
||||
<p>这一次，闭包以无主引用的形式捕获<code>self</code>，并不会持有<code>HTMLElement</code>实例的强引用。如果将<code>paragraph</code>赋值为<code>nil</code>，<code>HTMLElement</code>实例将会被销毁，并能看到它的析构函数打印出的消息。</p>
|
||||
<pre><code>paragraph = nil
|
||||
// prints "p is being deinitialized"
|
||||
</code></pre>
|
||||
|
||||
Reference in New Issue
Block a user