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

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>