jak wywołanie super w zamknięciu w Swift

Question

Chcę łańcucha FUNC do Super IMPL, coś w następujący

class BaseClass { 
    func myFunc() { 
    // do something 
    } 
} 

class MyClass: BaseClass { 
    override func myFunc() { 
    self.myOtherFunc(completionHandler: { 
     super.myFunc() // error: 'super' members cannot be referenced in a non-class type 
    }) 
    } 
    ... 
} 

Błąd kompilacji rzeczywiście mówi mi powód wyraźnie: zamknięcie nie jest to typ klasy i nie jest dozwolone. Szukasz jakiejkolwiek sugestii Jak mogę wywołać metodę zdefiniowaną w super klasie?

Answer 1

Aktualizacja: dzień Swift 1.2 b3, to zachowanie jest naprawione - oryginalny kod działa zgodnie z przeznaczeniem. Yay, postęp!

class BaseClass { 
    func myFunc() { 
     println("BaseClass.myFunc()") 
    } 
} 

class MyClass: BaseClass { 
    func myOtherFunc(c:() ->()) { 
     c() 
    } 

    override func myFunc() { 
     println("MyClass.myFunc()") 
     self.myOtherFunc { 
      super.myFunc() 
     } 
    } 
} 

MyClass().myFunc() 
// MyClass.myFunc() 
// BaseClass.myFunc() 

---

Idealnie można po prostu napisać:

class MyClass: BaseClass { 
    override func myFunc() { 
    let superFunc = super.myFunc 
    self.myOtherFunc(completionHandler: { 
     superFunc() 
    }) 
    } 
} 

Ale to nie działa, to po prostu wywołuje self.myFunc(). I tweeted about this innego dnia i dostałem response from one of the Swift developers, że jest to znany błąd. Jedynym sposobem obejścia tego problemu jest użycie innej metody przełączania połączenia na super:

class MyClass: BaseClass { 
    override func myFunc() { 
    self.myOtherFunc(completionHandler: { 
     self.callSuperMyFunc() 
    }) 
    } 

    func callSuperMyFunc() { 
    super.myFunc() 
    } 
} 

Answer 2

Ta odpowiedź może nie odpowiadając na pytanie ..

Niespodziewanie, poniższy kod powoduje nieskończoną rekurencyjne wywołanie. Może błąd?

class MyClass: BaseClass { 
    override func myFunc() { 
     let superMyFunc = super.myFunc 
     self.myOtherFunc(completionHandler: { 
      superMyFunc() // this actually calls MyClass.myFunc 
      return 
     }) 
    } 
} 

// ALSO 
class MyClass: BaseClass { 
    override func myFunc() { 
     let superMyFunc = BaseClass.myFunc(self as BaseClass) 
     self.myOtherFunc(completionHandler: { 
      superMyFunc() // this actually calls MyClass.myFunc 
      return 
     }) 
    } 
} 

Jedyne obejście się dowiedziałem jest określenie innego sposobu:

class MyClass: BaseClass { 
    override func myFunc() { 
     self.myOtherFunc(completionHandler: { 
      self.callSuperMyFunc() 
      return 
     }) 
    } 
    func callSuperMyFunc() { 
     super.myFunc() 
    } 
} 

Ale, jak sądzę, należy użyć innej nazwy metoda:

class MyClass: BaseClass { 
    func myFuncAsync() { 
     self.myOtherFunc(completionHandler: { 
      self.myFunc() 
      return 
     }) 
    } 
}