Extension

Extension

Les extensions te permettent d’ajouter de nouvelles fonctionnalités à des types existants, comme les classes, les structures, les énumérations ou même les types de base comme Int ou String. C’est pratique pour enrichir des types que tu n’as pas créés toi-même, sans modifier leur code d’origine.

Syntaxe

extension NameType {
    
}

Extension d’un type existant

extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 5
print(number.squared()) 

Lecture dans la console ->
2

L’exemple ci-dessus montre l’intérêt des extensions. Ici, nous avons ajouté la méthode squared() qui permet de retourner un entier avec sa valeur au carré. Cette méthode est utilisable sur tous les nombres entiers (Int). Comme il est impossible de modifier directement les types natifs de Swift, les extensions sont très utiles pour ajouter des fonctionnalités supplémentaires à ces types.

 Extension d’un type personnalisé

class Car {
    var make: String
    var model: String
    var year: Int

    init(make: String, model: String, year: Int) {
        self.make = make
        self.model = model
        self.year = year
    }
}

extension Car {
    func startEngine() -> String {
        return "La voiture \(make) \(model) démarre"
    }
}

let myCar = Car(make: "Renault", model: "Scenic", year: 2020)
print(myCar.startEngine())  

/*
Lecture dans la console ->
La voiture Renault Scenic démarre
*/<br />
extension Car {
    var age: Int {
        return 2024 - year
    }
}

print("Ma voiture a \(myCar.age) années d'ancienetté")  

/*
Lecture dans la console ->
Ma voiture à 4 années d'ancienetté 
*/
}

 Ajouter des initialiseurs

extension Car {
    convenience init(make: String, model: String) {
        self.init(make: make, model: model, year: 2024, color: "White")
    }
}


let newCar = Car(make: "Honda", model: "Civic")

print("Ma nouvelle voiture est une \(newCar.year) le modèle est une \(newCar.make) \(newCar.model) et elle est de couleur \(newCar.color).")

/*
Lecture dans la console ->
Ma nouvelle voiture est une 2024 le modèle est une Honda Civic et elle est de couleur blanche
*/

Une extension permet d’ajouter des initialisateurs, y compris des convenience init, pour enrichir un type sans toucher à sa définition d’origine. Les convenience init appellent un autre initialisateur du type pour garantir une configuration complète et rendent la création d’instances plus simple, notamment pour gérer des configurations par défaut ou fréquentes.

Extension d’un protocole

protocol Vehicule {
    var description: String { get }
    func describe()
}

extension Vehicule {
    func describe() {
        print(description)
    }
}

struct Moto: Vehicule {
    var model: String
    var year: Int
    
    var description: String {
        return "Modèle :  \(model), année : \(year)"
    }
}

struct Truck: Vehicule {
    var model: String
    var year: Int
    var capacity: Int
    
    var description: String {
        return "Modèle :\(model), année: \(year), capacité: \(capacity) tonnes"
    }
}

Les extensions marchent également sur les protocoles.

 Extensions pour conformer à un protocole

protocol Descriptible {
    var description: String { get }
}

extension Car: Descriptible {
    var description: String {
        return "\(make) \(model)"
    }
}

print("Ma voiture est une \(myCar.description).")  

/*
Lecture dans la console ->
Ma voiture est une Honda Civic
*/