make gitbook

2014-06-14 20:51:32 +08:00
parent e00caf63d5
commit 31f083eb83
68 changed files with 1893 additions and 1795 deletions
--- a/chapter2/11_Methods.html
+++ b/chapter2/11_Methods.html
@ -46,7 +46,7 @@


        
-    <div class="book"  data-level="2.11" data-basepath=".." data-revision="1402677669306">
+    <div class="book"  data-level="2.11" data-basepath=".." data-revision="1402750255397">
    <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>
@ -268,7 +268,7 @@
        <li class="chapter " data-level="2.12" data-path="chapter2/12_Subscripts.html">
            
            <a href="../chapter2/12_Subscripts.html">
-                <i class="fa fa-check"></i> <b>2.12.</b> 附属脚本
+                <i class="fa fa-check"></i> <b>2.12.</b> 下标脚本
            </a>
            
            
@ -520,7 +520,7 @@
    
        <a href="../chapter2/11_Methods.html" title="方法" class="chapter done " data-progress="2.11" style="left: 18.42105263157895%;"></a>
    
-        <a href="../chapter2/12_Subscripts.html" title="附属脚本" class="chapter  " data-progress="2.12" style="left: 21.05263157894737%;"></a>
+        <a href="../chapter2/12_Subscripts.html" title="下标脚本" class="chapter  " data-progress="2.12" style="left: 21.05263157894737%;"></a>
    
        <a href="../chapter2/13_Inheritance.html" title="继承" class="chapter  " data-progress="2.13" style="left: 23.68421052631579%;"></a>
    
@ -587,11 +587,10 @@

                <div class="page-inner">
                
-                    <section class="normal" id="section-gitbook_107">
+                    <section class="normal" id="section-gitbook_51">
                    
                        <blockquote>
-<p>翻译：pp-prog</p>
-<p>校对：zqp</p>
+<p>翻译：pp-prog<br>校对：zqp  </p>
 </blockquote>
 <h1 id="-methods-">方法（Methods）</h1>
 <hr>
@ -607,7 +606,7 @@
 <p><strong>实例方法</strong>是属于某个特定类、结构体或者枚举类型实例的方法。实例方法提供访问和修改实例属性的方法或提供与实例目的相关的功能，并以此来支撑实例的功能。实例方法的语法与函数完全一致，详情参见<a href="../charpter2/06_Functions.html">函数</a>。</p>
 <p>实例方法要写在它所属的类型的前后大括号之间。实例方法能够隐式访问它所属类型的所有的其他实例方法和属性。实例方法只能被它所属的类的某个特定实例调用。实例方法不能脱离于现存的实例而被调用。</p>
 <p>下面的例子，定义一个很简单的类<code>Counter</code>，<code>Counter</code>能被用来对一个动作发生的次数进行计数：</p>
-<pre><code>class Counter {
+<pre><code class="lang-swift">class Counter {
  var count = 0
  func increment() {
    count++
@ -619,7 +618,8 @@
    count = 0
  }
 }
-</code></pre><p><code>Counter</code>类定义了三个实例方法：</p>
+</code></pre>
+<p><code>Counter</code>类定义了三个实例方法：</p>
 <ul>
 <li><code>increment</code>让计数器按一递增；</li>
 <li><code>incrementBy(amount: Int)</code>让计数器按一个指定的整数值递增；</li>
@ -627,7 +627,7 @@
 </ul>
 <p><code>Counter</code>这个类还声明了一个可变属性<code>count</code>，用它来保持对当前计数器值的追踪。</p>
 <p>和调用属性一样，用点语法（dot syntax）调用实例方法：</p>
-<pre><code> let counter = Counter()
+<pre><code class="lang-swift"> let counter = Counter()
 // 初始计数值是0
 counter.increment()
 // 计数值现在是1
@ -635,28 +635,32 @@
 // 计数值现在是6
 counter.reset()
 // 计数值现在是0
-</code></pre><p><a name="local_and_external_parameter"></a></p>
+</code></pre>
+<p><a name="local_and_external_parameter"></a></p>
 <h3 id="-local-and-external-parameter-names-for-methods-">方法的局部参数名称和外部参数名称(Local and External Parameter Names for Methods)</h3>
 <p>函数参数可以同时有一个局部名称（在函数体内部使用）和一个外部名称（在调用函数时使用），详情参见<a href="06_Functions.html">函数的外部参数名</a>。方法参数也一样（因为方法就是函数，只是这个函数与某个类型相关联了）。但是，方法和函数的局部名称和外部名称的默认行为是不一样的。</p>
 <p>Swift 中的方法和 Objective-C 中的方法极其相似。像在 Objective-C 中一样，Swift 中方法的名称通常用一个介词指向方法的第一个参数，比如：<code>with</code>，<code>for</code>，<code>by</code>等等。前面的<code>Counter</code>类的例子中<code>incrementBy</code>方法就是这样的。介词的使用让方法在被调用时能像一个句子一样被解读。和函数参数不同，对于方法的参数，Swift 使用不同的默认处理方式，这可以让方法命名规范更容易写。</p>
 <p>具体来说，Swift  默认仅给方法的第一个参数名称一个局部参数名称;默认同时给第二个和后续的参数名称局部参数名称和外部参数名称。这个约定与典型的命名和调用约定相适应，与你在写 Objective-C 的方法时很相似。这个约定还让表达式方法在调用时不需要再限定参数名称。</p>
 <p>看看下面这个<code>Counter</code>的另一个版本（它定义了一个更复杂的<code>incrementBy</code>方法）：</p>
-<pre><code>class Counter {
+<pre><code class="lang-swift">class Counter {
  var count: Int = 0
  func incrementBy(amount: Int, numberOfTimes: Int) {
    count += amount * numberOfTimes
  }
 }
-</code></pre><p><code>incrementBy</code>方法有两个参数： <code>amount</code>和<code>numberOfTimes</code>。默认情况下，Swift 只把<code>amount</code>当作一个局部名称，但是把<code>numberOfTimes</code>即看作局部名称又看作外部名称。下面调用这个方法：</p>
-<pre><code>let counter = Counter()
+</code></pre>
+<p><code>incrementBy</code>方法有两个参数： <code>amount</code>和<code>numberOfTimes</code>。默认情况下，Swift 只把<code>amount</code>当作一个局部名称，但是把<code>numberOfTimes</code>即看作局部名称又看作外部名称。下面调用这个方法：</p>
+<pre><code class="lang-swift">let counter = Counter()
 counter.incrementBy(5, numberOfTimes: 3)
 // counter value is now 15
-</code></pre><p>你不必为第一个参数值再定义一个外部变量名：因为从函数名<code>incrementBy</code>已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。</p>
+</code></pre>
+<p>你不必为第一个参数值再定义一个外部变量名：因为从函数名<code>incrementBy</code>已经能很清楚地看出它的作用。但是第二个参数，就要被一个外部参数名称所限定，以便在方法被调用时明确它的作用。</p>
 <p>这种默认的行为能够有效的处理方法（method）,类似于在参数<code>numberOfTimes</code>前写一个井号（<code>#</code>）：</p>
-<pre><code>func incrementBy(amount: Int, #numberOfTimes: Int) {
- count += amount * numberOfTimes
+<pre><code class="lang-swift">func incrementBy(amount: Int, #numberOfTimes: Int) {
+  count += amount * numberOfTimes
 }
-</code></pre><p>这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。</p>
+</code></pre>
+<p>这种默认行为使上面代码意味着：在 Swift 中定义方法使用了与 Objective-C 同样的语法风格，并且方法将以自然表达式的方式被调用。</p>
 <p><a name="modifying_external_parameter"></a></p>
 <h3 id="-modifying-external-parameter-name-behavior-for-methods-">修改方法的外部参数名称(Modifying External Parameter Name Behavior for Methods)</h3>
 <p>有时为方法的第一个参数提供一个外部参数名称是非常有用的，尽管这不是默认的行为。你可以自己添加一个显式的外部名称或者用一个井号（<code>#</code>）作为第一个参数的前缀来把这个局部名称当作外部名称使用。</p>
@ -665,13 +669,14 @@ counter.incrementBy(5, numberOfTimes: 3)
 <h2 id="-self-the-self-property-"><code>self</code>属性(The self Property)</h2>
 <p>类型的每一个实例都有一个隐含属性叫做<code>self</code>，<code>self</code>完全等同于该实例本身。你可以在一个实例的实例方法中使用这个隐含的<code>self</code>属性来引用当前实例。</p>
 <p>上面例子中的<code>increment</code>方法还可以这样写：</p>
-<pre><code>func increment() {
+<pre><code class="lang-swift">func increment() {
  self.count++
 }
-</code></pre><p>实际上，你不必在你的代码里面经常写<code>self</code>。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写<code>self</code>，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的<code>Counter</code>中已经示范了：<code>Counter</code>中的三个实例方法中都使用的是<code>count</code>（而不是<code>self.count</code>）。</p>
+</code></pre>
+<p>实际上，你不必在你的代码里面经常写<code>self</code>。不论何时，只要在一个方法中使用一个已知的属性或者方法名称，如果你没有明确的写<code>self</code>，Swift 假定你是指当前实例的属性或者方法。这种假定在上面的<code>Counter</code>中已经示范了：<code>Counter</code>中的三个实例方法中都使用的是<code>count</code>（而不是<code>self.count</code>）。</p>
 <p>使用这条规则的主要场景是实例方法的某个参数名称与实例的某个属性名称相同的时候。在这种情况下，参数名称享有优先权，并且在引用属性时必须使用一种更严格的方式。这时你可以使用<code>self</code>属性来区分参数名称和属性名称。</p>
 <p>下面的例子中，<code>self</code>消除方法参数<code>x</code>和实例属性<code>x</code>之间的歧义：</p>
-<pre><code>struct Point {
+<pre><code class="lang-swift">struct Point {
  var x = 0.0, y = 0.0
  func isToTheRightOfX(x: Double) -&gt; Bool {
    return self.x &gt; x
@ -682,13 +687,14 @@ if somePoint.isToTheRightOfX(1.0) {
  println(&quot;This point is to the right of the line where x == 1.0&quot;)
 }
 // 输出 &quot;This point is to the right of the line where x == 1.0&quot;（这个点在x等于1.0这条线的右边）
-</code></pre><p>如果不使用<code>self</code>前缀，Swift 就认为两次使用的<code>x</code>都指的是名称为<code>x</code>的函数参数。</p>
+</code></pre>
+<p>如果不使用<code>self</code>前缀，Swift 就认为两次使用的<code>x</code>都指的是名称为<code>x</code>的函数参数。</p>
 <p><a name="modifying_value_types"></a></p>
 <h3 id="-modifying-value-types-from-within-instance-methods-">在实例方法中修改值类型(Modifying Value Types from Within Instance Methods)</h3>
 <p>结构体和枚举是<strong>值类型</strong>。一般情况下，值类型的属性不能在它的实例方法中被修改。</p>
 <p>但是，如果你确实需要在某个具体的方法中修改结构体或者枚举的属性，你可以选择<code>变异(mutating)</code>这个方法，然后方法就可以从方法内部改变它的属性；并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的<code>self</code>属性赋值一个全新的实例，这个新实例在方法结束后将替换原来的实例。</p>
 <p>要使用<code>变异</code>方法， 将关键字<code>mutating</code> 放到方法的<code>func</code>关键字之前就可以了：</p>
-<pre><code>struct Point {
+<pre><code class="lang-swift">struct Point {
  var x = 0.0, y = 0.0
  mutating func moveByX(deltaX: Double, y deltaY: Double) {
    x += deltaX
@ -699,23 +705,26 @@ var somePoint = Point(x: 1.0, y: 1.0)
 somePoint.moveByX(2.0, y: 3.0)
 println(&quot;The point is now at (\(somePoint.x), \(somePoint.y))&quot;)
 // 输出 &quot;The point is now at (3.0, 4.0)&quot;
-</code></pre><p>上面的<code>Point</code>结构体定义了一个变异方法（mutating method）<code>moveByX</code>，<code>moveByX</code>用来移动点。<code>moveByX</code>方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上<code>mutating</code>关键字,这才让方法可以修改值类型的属性。</p>
+</code></pre>
+<p>上面的<code>Point</code>结构体定义了一个变异方法（mutating method）<code>moveByX</code>，<code>moveByX</code>用来移动点。<code>moveByX</code>方法在被调用时修改了这个点，而不是返回一个新的点。方法定义时加上<code>mutating</code>关键字,这才让方法可以修改值类型的属性。</p>
 <p>注意：不能在结构体类型常量上调用变异方法，因为常量的属性不能被改变，即使想改变的是常量的变量属性也不行，详情参见<a href="&quot;10_Properties.html&quot;">存储属性和实例变量</a></p>
-<pre><code>let fixedPoint = Point(x: 3.0, y: 3.0)
+<pre><code class="lang-swift">let fixedPoint = Point(x: 3.0, y: 3.0)
 fixedPoint.moveByX(2.0, y: 3.0)
 // this will report an error
-</code></pre><p><a name="mutating_method_self"></a></p>
+</code></pre>
+<p><a name="mutating_method_self"></a></p>
 <h3 id="-self-assigning-to-self-within-a-mutating-method-">在变异方法中给self赋值(Assigning to self Within a Mutating Method)</h3>
 <p>变异方法能够赋给隐含属性<code>self</code>一个全新的实例。上面<code>Point</code>的例子可以用下面的方式改写：</p>
-<pre><code>struct Point {
+<pre><code class="lang-swift">struct Point {
  var x = 0.0, y = 0.0
  mutating func moveByX(deltaX: Double, y deltaY: Double) {
    self = Point(x: x + deltaX, y: y + deltaY)
  }
 }
-</code></pre><p>新版的变异方法<code>moveByX</code>创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。</p>
+</code></pre>
+<p>新版的变异方法<code>moveByX</code>创建了一个新的结构（它的 x 和 y 的值都被设定为目标值）。调用这个版本的方法和调用上个版本的最终结果是一样的。</p>
 <p>枚举的变异方法可以把<code>self</code>设置为相同的枚举类型中不同的成员：</p>
-<pre><code>enum TriStateSwitch {
+<pre><code class="lang-swift">enum TriStateSwitch {
  case Off, Low, High
  mutating func next() {
    switch self {
@ -733,26 +742,27 @@ ovenLight.next()
 // ovenLight 现在等于 .High
 ovenLight.next()
 // ovenLight 现在等于 .Off
-</code></pre><p>上面的例子中定义了一个三态开关的枚举。每次调用<code>next</code>方法时，开关在不同的电源状态（<code>Off</code>，<code>Low</code>，<code>High</code>）之前循环切换。</p>
+</code></pre>
+<p>上面的例子中定义了一个三态开关的枚举。每次调用<code>next</code>方法时，开关在不同的电源状态（<code>Off</code>，<code>Low</code>，<code>High</code>）之前循环切换。</p>
 <p><a name="type_methods"></a></p>
 <h2 id="-type-methods-">类型方法(Type Methods)</h2>
 <p>实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法，这种方法就叫做<strong>类型方法</strong>。声明类的类型方法，在方法的<code>func</code>关键字之前加上关键字<code>class</code>；声明结构体和枚举的类型方法，在方法的<code>func</code>关键字之前加上关键字<code>static</code>。</p>
 <blockquote>
-<p>注意：</p>
-<p>在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。</p>
+<p>注意：<br>在 Objective-C 里面，你只能为 Objective-C 的类定义类型方法（type-level methods）。在 Swift 中，你可以为所有的类、结构体和枚举定义类型方法：每一个类型方法都被它所支持的类型显式包含。  </p>
 </blockquote>
 <p>类型方法和实例方法一样用点语法调用。但是，你是在类型层面上调用这个方法，而不是在实例层面上调用。下面是如何在<code>SomeClass</code>类上调用类型方法的例子：</p>
-<pre><code>class SomeClass {
+<pre><code class="lang-swift">class SomeClass {
  class func someTypeMethod() {
    // type method implementation goes here
  }
 }
 SomeClass.someTypeMethod()
-</code></pre><p>在类型方法的方法体（body）中，<code>self</code>指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用<code>self</code>来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。</p>
+</code></pre>
+<p>在类型方法的方法体（body）中，<code>self</code>指向这个类型本身，而不是类型的某个实例。对于结构体和枚举来说，这意味着你可以用<code>self</code>来消除静态属性和静态方法参数之间的歧义（类似于我们在前面处理实例属性和实例方法参数时做的那样）。</p>
 <p>一般来说，任何未限定的方法和属性名称，将会来自于本类中另外的类型级别的方法和属性。一个类型方法可以调用本类中另一个类型方法的名称，而无需在方法名称前面加上类型名称的前缀。同样，结构体和枚举的类型方法也能够直接通过静态属性的名称访问静态属性，而不需要类型名称前缀。</p>
 <p>下面的例子定义了一个名为<code>LevelTracker</code>结构体。它监测玩家的游戏发展情况（游戏的不同层次或阶段）。这是一个单人游戏，但也可以存储多个玩家在同一设备上的游戏信息。</p>
 <p>游戏初始时，所有的游戏等级（除了等级 1）都被锁定。每次有玩家完成一个等级，这个等级就对这个设备上的所有玩家解锁。<code>LevelTracker</code>结构体用静态属性和方法监测游戏的哪个等级已经被解锁。它还监测每个玩家的当前等级。</p>
-<pre><code>struct LevelTracker {
+<pre><code class="lang-swift">struct LevelTracker {
  static var highestUnlockedLevel = 1
  static func unlockLevel(level: Int) {
    if level &gt; highestUnlockedLevel { highestUnlockedLevel = level }
@ -770,12 +780,13 @@ SomeClass.someTypeMethod()
    }
  }
 }
-</code></pre><p><code>LevelTracker</code>监测玩家的已解锁的最高等级。这个值被存储在静态属性<code>highestUnlockedLevel</code>中。</p>
+</code></pre>
+<p><code>LevelTracker</code>监测玩家的已解锁的最高等级。这个值被存储在静态属性<code>highestUnlockedLevel</code>中。</p>
 <p><code>LevelTracker</code>还定义了两个类型方法与<code>highestUnlockedLevel</code>配合工作。第一个类型方法是<code>unlockLevel</code>：一旦新等级被解锁，它会更新<code>highestUnlockedLevel</code>的值。第二个类型方法是<code>levelIsUnlocked</code>：如果某个给定的等级已经被解锁，它将返回<code>true</code>。（注意：尽管我们没有使用类似<code>LevelTracker.highestUnlockedLevel</code>的写法，这个类型方法还是能够访问静态属性<code>highestUnlockedLevel</code>）</p>
 <p>除了静态属性和类型方法，<code>LevelTracker</code>还监测每个玩家的进度。它用实例属性<code>currentLevel</code>来监测玩家当前的等级。</p>
 <p>为了便于管理<code>currentLevel</code>属性，<code>LevelTracker</code>定义了实例方法<code>advanceToLevel</code>。这个方法会在更新<code>currentLevel</code>之前检查所请求的新等级是否已经解锁。<code>advanceToLevel</code>方法返回布尔值以指示是否能够设置<code>currentLevel</code>。</p>
 <p>下面，<code>Player</code>类使用<code>LevelTracker</code>来监测和更新每个玩家的发展进度：</p>
-<pre><code>class Player {
+<pre><code class="lang-swift">class Player {
  var tracker = LevelTracker()
  let playerName: String
  func completedLevel(level: Int) {
@ -786,22 +797,24 @@ SomeClass.someTypeMethod()
    playerName = name
  }
 }
-</code></pre><p><code>Player</code>类创建一个新的<code>LevelTracker</code>实例来监测这个用户的发展进度。他提供了<code>completedLevel</code>方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了<code>advanceToLevel</code>返回的布尔值，因为之前调用<code>LevelTracker.unlockLevel</code>时就知道了这个等级已经被解锁了）。</p>
+</code></pre>
+<p><code>Player</code>类创建一个新的<code>LevelTracker</code>实例来监测这个用户的发展进度。它提供了<code>completedLevel</code>方法：一旦玩家完成某个指定等级就调用它。这个方法为所有玩家解锁下一等级，并且将当前玩家的进度更新为下一等级。（我们忽略了<code>advanceToLevel</code>返回的布尔值，因为之前调用<code>LevelTracker.unlockLevel</code>时就知道了这个等级已经被解锁了）。</p>
 <p>你还可以为一个新的玩家创建一个<code>Player</code>的实例，然后看这个玩家完成等级一时发生了什么：</p>
-<pre><code>var player = Player(name: &quot;Argyrios&quot;)
+<pre><code class="lang-swift">var player = Player(name: &quot;Argyrios&quot;)
 player.completedLevel(1)
 println(&quot;highest unlocked level is now \(LevelTracker.highestUnlockedLevel)&quot;)
-// 输出 &quot;highest unlocked level is now 2&quot;（最高等级现在是2
-）
-</code></pre><p>如果你创建了第二个玩家，并尝试让他开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：</p>
-<pre><code>player = Player(name: &quot;Beto&quot;)
+// 输出 &quot;highest unlocked level is now 2&quot;（最高等级现在是2）
+</code></pre>
+<p>如果你创建了第二个玩家，并尝试让它开始一个没有被任何玩家解锁的等级，那么这次设置玩家当前等级的尝试将会失败：</p>
+<pre><code class="lang-swift">player = Player(name: &quot;Beto&quot;)
 if player.tracker.advanceToLevel(6) {
-println(&quot;player is now on level 6&quot;)
+  println(&quot;player is now on level 6&quot;)
 } else {
-println(&quot;level 6 has not yet been unlocked&quot;)
+  println(&quot;level 6 has not yet been unlocked&quot;)
 }
 // 输出 &quot;level 6 has not yet been unlocked&quot;（等级6还没被解锁）
 </code></pre>
+
                    
                    </section>
                
@ -813,7 +826,7 @@ println(&quot;level 6 has not yet been unlocked&quot;)
        <a href="../chapter2/10_Properties.html" class="navigation navigation-prev " aria-label="Previous page: 属性"><i class="fa fa-angle-left"></i></a>
        
        
-        <a href="../chapter2/12_Subscripts.html" class="navigation navigation-next " aria-label="Next page: 附属脚本"><i class="fa fa-angle-right"></i></a>
+        <a href="../chapter2/12_Subscripts.html" class="navigation navigation-next " aria-label="Next page: 下标脚本"><i class="fa fa-angle-right"></i></a>
        
    </div>
 </div>