Swift Language
Rozszerzenia

Uwagi

Zmienne i funkcje

Rozszerzenia mogą zawierać funkcje i obliczane / stałe zmienne get. Są w formacie

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

Aby odwołać się do wystąpienia rozszerzonego obiektu, można użyć self , tak jak można go użyć

Aby utworzyć rozszerzenie String , która dodaje .length() funkcja, która zwraca długość łańcucha, na przykład

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

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

Rozszerzenia mogą również zawierać zmienne get . Na przykład dodanie zmiennej .length do łańcucha, która zwraca długość łańcucha

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

"Hello, World!".length // 13

Inicjatory w rozszerzeniach

Rozszerzenia mogą zawierać wygodne inicjatory. Na przykład awaryjny inicjalizator dla Int który akceptuje NSString :

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

Co to są rozszerzenia?

Rozszerzenia służą do rozszerzania funkcjonalności istniejących typów w Swift. Rozszerzenia mogą dodawać indeksy dolne, funkcje, inicjatory i właściwości obliczane. Mogą także dostosowywać typy do protokołów .

Załóżmy, że chcemy, aby móc obliczyć silnię danego Int . Możesz dodać obliczoną właściwość w rozszerzeniu:

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

Następnie możesz uzyskać dostęp do właściwości tak, jakby była zawarta w oryginalnym Int API.

let val1: Int = 10

val1.factorial  // returns 3628800

Rozszerzenia protokołu

Bardzo przydatną funkcją Swift 2.2 jest możliwość rozszerzania protokołów.

Działa podobnie jak klasy abstrakcyjne, jeśli chodzi o funkcjonalność, która ma być dostępna we wszystkich klasach, które implementują jakiś protokół (bez konieczności dziedziczenia z podstawowej wspólnej klasy).

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
    }
}

Jest to również możliwe przy użyciu ogólnych.

Ograniczenia

Możliwe jest napisanie metody typu ogólnego, która jest bardziej restrykcyjna przy użyciu zdania where.

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

Przykład zastosowania

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

Co to są rozszerzenia i kiedy ich używać

Rozszerzenia dodają nową funkcjonalność do istniejącej klasy, struktury, wyliczenia lub typu protokołu. Obejmuje to możliwość rozszerzenia typów, dla których nie masz dostępu do oryginalnego kodu źródłowego.

Rozszerzenia w Swift mogą:

• Dodaj obliczone właściwości i obliczone właściwości typu
• Zdefiniuj metody instancji i metody typów
• Zapewnij nowe inicjatory
• Zdefiniuj indeksy dolne
• Zdefiniuj i używaj nowych typów zagnieżdżonych
• Dostosuj istniejący typ do protokołu

Kiedy używać rozszerzeń Swift:

• Dodatkowa funkcjonalność do Swift
• Dodatkowa funkcjonalność do UIKit / Foundation
• Dodatkowa funkcjonalność bez bałaganu z kodem innych osób
• Podział klas na: Dane / Funkcjonalność / Delegat

Kiedy nie należy używać:

• Rozszerz swoje własne klasy z innego pliku

Prosty przykład:

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

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

Źródło

Indeksy dolne

Rozszerzenia mogą dodawać nowe indeksy dolne do istniejącego typu.

W tym przykładzie znak jest wstawiany do ciągu za pomocą podanego indeksu:

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