Swift Language
uitbreidingen

Opmerkingen

Variabelen en functies

Extensies kunnen functies en berekende / constante get-variabelen bevatten. Ze hebben het formaat

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

Om naar de instantie van het uitgebreide object te verwijzen, kan self worden gebruikt, net zoals het zou kunnen worden gebruikt

Om een extensie van String die een .length() -functie toevoegt die bijvoorbeeld de lengte van de string retourneert

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

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

Extensies kunnen ook get variabelen bevatten. Als u bijvoorbeeld een variabele .length toevoegt aan de tekenreeks die de lengte van de tekenreeks retourneert

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

"Hello, World!".length // 13

Initializers in extensies

Extensies kunnen gemakinitializers bevatten. Een beschikbare initialisatie voor Int die een NSString accepteert:

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

Wat zijn extensies?

Extensies worden gebruikt om de functionaliteit van bestaande typen in Swift uit te breiden. Extensies kunnen subscripts, functies, initializers en berekende eigenschappen toevoegen. Ze kunnen ook typen conform maken met protocollen .

Stel dat u de faculteit van een Int wilt kunnen berekenen. U kunt een berekende eigenschap toevoegen aan een extensie:

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

Vervolgens hebt u toegang tot de eigenschap alsof deze was opgenomen in de oorspronkelijke Int API.

let val1: Int = 10

val1.factorial  // returns 3628800

Protocol uitbreidingen

Een zeer handige functie van Swift 2.2 is het uitbreiden van protocollen.

Het werkt vrijwel als abstracte klassen wanneer het een functionaliteit betreft die u beschikbaar wilt hebben in alle klassen die een protocol implementeren (zonder te moeten erven van een algemene basisklasse).

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

Dit is ook mogelijk met behulp van generieke geneesmiddelen.

beperkingen

Het is mogelijk om een methode te schrijven op een generiek type dat restrictiever is met waar zin.

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

Voorbeeld van gebruik

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

Wat zijn extensies en wanneer deze te gebruiken

Extensies voegen nieuwe functionaliteit toe aan een bestaande klasse, structuur, opsomming of protocoltype. Dit omvat de mogelijkheid om typen uit te breiden waarvoor u geen toegang hebt tot de oorspronkelijke broncode.

Extensies in Swift kunnen:

• Berekende eigenschappen en berekende type-eigenschappen toevoegen
• Definieer instantiemethoden en typemethoden
• Zorg voor nieuwe initializers
• Definieer subscripts
• Definieer en gebruik nieuwe geneste typen
• Maak een bestaand type conform aan een protocol

Wanneer Swift Extensions gebruiken:

• Extra functionaliteit voor Swift
• Extra functionaliteit voor UIKit / Foundation
• Extra functionaliteit zonder de code van andere personen te verknoeien
• Verdeling klassen in: Data / Functionaliteit / Delegeren

Wanneer niet te gebruiken:

• Breid uw eigen klassen uit vanuit een ander bestand

Eenvoudig voorbeeld:

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

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

Bron

subscripts

Extensies kunnen nieuwe subscripts toevoegen aan een bestaand type.

In dit voorbeeld wordt het teken in een string geplaatst met behulp van de gegeven index:

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