Swift Language
Extensions

Anmärkningar

Variabler och funktioner

Extensions kan innehålla funktioner och beräkna / konstant få variabler. De är i formatet

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

För att hänvisa till förekomsten av det utökade objektet kan self använda, precis som det kan användas

För att skapa en förlängning av String som lägger till en .length() -funktion som till exempel returnerar strängens längd

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

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

Extensions kan också innehålla get variabler. Till exempel lägger du till en .length till strängen som returnerar längden på strängen

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

"Hello, World!".length // 13

Initierare i tillägg

Tillägg kan innehålla bekvämlighetsinitierare. Till exempel en tillgänglig initialisator för Int som accepterar en 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

Vad är tillägg?

Tillägg används för att utöka funktionaliteten för befintliga typer i Swift. Tillägg kan lägga till abonnemang, funktioner, initialiseringar och beräkningsegenskaper. De kan också göra att typer överensstämmer med protokoll .

Anta att du vill kunna beräkna factorial of a Int . Du kan lägga till en beräknad egenskap i en tillägg:

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

Då kan du få åtkomst till fastigheten precis som om den hade inkluderats i det ursprungliga Int API.

let val1: Int = 10

val1.factorial  // returns 3628800

Protokollförlängningar

En mycket användbar funktion i Swift 2.2 är att ha förlängning av protokoll.

Det fungerar ganska mycket som abstrakta klasser när det gäller en funktionalitet du vill vara tillgänglig i alla klasser som implementerar något protokoll (utan att behöva ärva från en gemensam basklass).

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

Detta är också möjligt med generiska.

begränsningar

Det är möjligt att skriva en metod på en generisk typ som är mer restriktiv med användning av där mening.

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

Exempel på användning

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

Vad är tillägg och när du ska använda dem

Tillägg lägger till ny funktionalitet i en befintlig klass, struktur, uppräkning eller protokolltyp. Detta inkluderar möjligheten att utöka typer som du inte har tillgång till den ursprungliga källkoden.

Extensions i Swift kan:

• Lägg till beräknade egenskaper och egenskaper för beräknad typ
• Definiera instansmetoder och typmetoder
• Ge nya initialiseringar
• Definiera abonnemang
• Definiera och använda nya kapslade typer
• Få en befintlig typ att överensstämma med ett protokoll

När du ska använda Swift Extensions:

• Ytterligare funktioner för Swift
• Ytterligare funktionalitet till UIKit / Foundation
• Ytterligare funktionalitet utan att röra med annan persons kod
• Uppdelningsklasser i: Data / Funktionalitet / Delegat

När du inte ska använda:

• Förläng dina egna klasser från en annan fil

Enkelt exempel:

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

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

Källa

index

Tillägg kan lägga till nya abonnemang till en befintlig typ.

Detta exempel får karaktären inuti en sträng med det angivna indexet:

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