Swift Language
Les extensions

Remarques

Variables et fonctions

Les extensions peuvent contenir des fonctions et des variables get / constantes. Ils sont dans le format

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

Pour référencer l'instance de l'objet étendu, self peut être utilisé, tout comme il pourrait être utilisé

Pour créer une extension de String qui ajoute une fonction .length() qui renvoie la longueur de la chaîne, par exemple

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

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

Les extensions peuvent également contenir des variables get . Par exemple, ajouter une variable .length à la chaîne qui renvoie la longueur de la chaîne

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

"Hello, World!".length // 13

Initialiseurs dans les extensions

Les extensions peuvent contenir des initialiseurs de commodité. Par exemple, un initialiseur disponible pour Int qui accepte un 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

Que sont les extensions?

Les extensions permettent d'étendre les fonctionnalités des types existants dans Swift. Les extensions peuvent ajouter des indices, des fonctions, des initialiseurs et des propriétés calculées. Ils peuvent également faire en sorte que les types soient conformes aux protocoles .

Supposons que vous souhaitiez pouvoir calculer la factorielle d'un Int . Vous pouvez ajouter une propriété calculée dans une extension:

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

Vous pouvez ensuite accéder à la propriété comme si elle avait été incluse dans l'API Int d'origine.

let val1: Int = 10

val1.factorial  // returns 3628800

Extensions de protocole

Une fonctionnalité très utile de Swift 2.2 est la possibilité d’étendre les protocoles.

Cela fonctionne à peu près comme les classes abstraites quand il s'agit d'une fonctionnalité que vous voulez être disponible dans toutes les classes qui implémentent un protocole (sans devoir hériter d'une classe commune de base).

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

Ceci est également possible en utilisant des génériques.

Restrictions

Il est possible d'écrire une méthode sur un type générique plus restrictif en utilisant where phrase.

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

Exemple d'utilisation

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

Que sont les extensions et quand les utiliser

Les extensions ajoutent de nouvelles fonctionnalités à une classe, une structure, une énumération ou un type de protocole existant. Cela inclut la possibilité d'étendre les types pour lesquels vous n'avez pas accès au code source d'origine.

Les extensions dans Swift peuvent:

• Ajouter des propriétés calculées et des propriétés de type calculées
• Définir des méthodes d'instance et des méthodes de type
• Fournir de nouveaux initialiseurs
• Définir des indices
• Définir et utiliser de nouveaux types imbriqués
• Rendre un type existant conforme à un protocole

Quand utiliser les extensions Swift:

• Fonctionnalité supplémentaire à Swift
• Fonctionnalité supplémentaire pour UIKit / Foundation
• Fonctionnalité supplémentaire sans déranger le code des autres personnes
• Classes de décomposition en: Données / Fonctionnalité / Délégué

Quand ne pas utiliser:

• Étendre vos propres classes à partir d'un autre fichier

Exemple simple:

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

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

La source

Des indices

Les extensions peuvent ajouter de nouveaux indices à un type existant.

Cet exemple obtient le caractère à l'intérieur d'une chaîne en utilisant l'index donné:

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