Swift Language
Erweiterungen

Bemerkungen

Variablen und Funktionen

Erweiterungen können Funktionen und berechnete / konstante get-Variablen enthalten. Sie haben das Format

extension ExtensionOf {
    //new functions and get-variables
}

Um auf die Instanz des erweiterten Objekts zu verweisen, kann self genauso verwendet werden, wie es verwendet werden könnte

So erstellen Sie eine Erweiterung von String , die eine .length() Funktion hinzufügt, die beispielsweise die Länge des Strings zurückgibt

extension String {
    func length() -> Int {
        return self.characters.count
    }
}

"Hello, World!".length() // 13

Erweiterungen können auch get Variablen enthalten. .length dem String beispielsweise eine .length Variable hinzu, die die Länge des Strings zurückgibt

extension String {
    var length: Int {
        get {
            return self.characters.count
        }
    }
}

"Hello, World!".length // 13

Initialisierer in Erweiterungen

Erweiterungen können praktische Initialisierer enthalten. Zum Beispiel eine fehlgeschlagene Initialisierung für Int , die einen NSString akzeptiert:

extension Int {
    init?(_ string: NSString) {
        self.init(string as String)  // delegate to the existing Int.init(String) initializer
    }
}

let str1: NSString = "42"
Int(str1) // 42

let str2: NSString = "abc"
Int(str2) // nil

Was sind Erweiterungen?

Erweiterungen werden verwendet, um die Funktionalität vorhandener Typen in Swift zu erweitern. Erweiterungen können Subskripte, Funktionen, Initialisierer und berechnete Eigenschaften hinzufügen. Sie können auch Typen protokollkonform machen .

Angenommen, Sie möchten die Fakultät eines Int berechnen können. Sie können eine berechnete Eigenschaft in eine Erweiterung einfügen:

extension Int {
    var factorial: Int {
        return (1..<self+1).reduce(1, combine: *)
    }
}

Dann können Sie auf die Eigenschaft zugreifen, als ob sie in der ursprünglichen Int-API enthalten wäre.

let val1: Int = 10

val1.factorial  // returns 3628800

Protokollerweiterungen

Eine sehr nützliche Funktion von Swift 2.2 ist die Möglichkeit, Protokolle zu erweitern.

Es funktioniert ähnlich wie abstrakte Klassen, wenn es um eine Funktionalität geht, die in allen Klassen verfügbar sein soll, die ein Protokoll implementieren (ohne von einer allgemeinen Basisklasse zu erben).

protocol FooProtocol {
    func doSomething()
}

extension FooProtocol {
    func doSomething() {
        print("Hi")
    }
}

class Foo: FooProtocol {
    func myMethod() {
        doSomething() // By just implementing the protocol this method is available
    }
}

Dies ist auch mit Generika möglich.

Beschränkungen

Es ist möglich, eine Methode für einen generischen Typ zu schreiben, der mit Where-Satz restriktiver ist.

extension Array where Element: StringLiteralConvertible {
  func toUpperCase() -> [String] {
      var result = [String]()
      for value in self {
          result.append(String(value).uppercaseString)
      }
      return result
    }        
}

Anwendungsbeispiel

let array = ["a","b","c"]
let resultado = array.toUpperCase()

Was sind Erweiterungen und wann werden sie verwendet?

Erweiterungen fügen einer vorhandenen Klasse, Struktur, Aufzählung oder einem Protokolltyp neue Funktionen hinzu. Dies beinhaltet die Möglichkeit, Typen zu erweitern, für die Sie keinen Zugriff auf den ursprünglichen Quellcode haben.

Erweiterungen in Swift können:

• Fügen Sie berechnete Eigenschaften und Eigenschaften des berechneten Typs hinzu
• Definieren Sie Instanzmethoden und Typmethoden
• Neue Initialisierer bereitstellen
• Subskriptionen definieren
• Definieren und Verwenden neuer verschachtelter Typen
• Einen vorhandenen Typ an ein Protokoll anpassen

Wann sollten Sie Swift Extensions verwenden:

• Zusatzfunktionen zu Swift
• Zusätzliche Funktionalität für UIKit / Foundation
• Zusätzliche Funktionalität, ohne den Code anderer Personen zu missbrauchen
• Unterteilen Sie die Klassen in: Daten / Funktionalität / Delegieren

Wann nicht verwenden:

• Erweitern Sie Ihre eigenen Klassen aus einer anderen Datei

Einfaches Beispiel:

extension Bool {
    public mutating func toggle() -> Bool {
        self = !self
        return self
    }
}

var myBool: Bool = true
print(myBool.toggle()) // false

Quelle

Abonnements

Erweiterungen können einem vorhandenen Typ neue Subskripte hinzufügen.

In diesem Beispiel wird das Zeichen in einem String mit dem angegebenen Index abgerufen:

extension String {
    subscript(index: Int) -> Character {
        let newIndex = startIndex.advancedBy(index)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c

extension String {
    subscript(offset: Int) -> Character {
        let newIndex = self.index(self.startIndex, offsetBy: offset)
        return self[newIndex]
    }
}

var myString = "StackOverFlow"
print(myString[2]) // a
print(myString[3]) // c