Extension en Swift : définition, syntaxe et comment ajouter des méthodes

Qu’est-ce que Extension en Swift ?

Extension en Swift est une construction du langage qui permet d’étendre un type existant (classe, structure, enum, protocole) avec de nouvelles capacités. C’est similaire aux catégories en Objective-C mais plus puissant.

Extension peut ajouter :

• Propriétés calculées — d’instance et de type
• Méthodes — d’instance et de type
• Initialiseurs (convenience init)
• Subscripts
• Types imbriqués
• Conformités aux protocoles

Selon la documentation Apple, extension ne peut pas surcharger les méthodes existantes (dispatch dynamique) et ne peut pas ajouter de propriétés stockées. Ces limitations préservent l’intégrité du type d’origine.

Syntaxe des extensions

Extension se déclare avec le mot-clé extension suivi du type à étendre.

extension Double {
    var km: Double { return self * 1000.0 }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1000.0 }
}

let distance = 5.0.km
print("5 km = \(distance) meters") // 5000.0

On peut étendre non seulement ses propres types mais aussi les types de la bibliothèque standard de Swift, Foundation, UIKit et d’autres frameworks. Cela fait de extension un outil puissant pour ajouter des fonctionnalités spécifiques au domaine.

Ajouter des méthodes via extension

Extension permet d’ajouter des méthodes d’instance et de type à tout type existant.

extension String {
    func isValidEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}"
        return self.range(of: emailRegex, options: .regularExpression) != nil
    }

    static func random(length: Int) -> String {
        let letters = "abcdefghijklmnopqrstuvwxyz0123456789"
        return String((0..<length).map { _ in letters.randomElement()! })
    }
}

let email = "user@example.com"
print(email.isValidEmail()) // true
let code = String.random(length: 8) // "a3f8k2m1"

Les méthodes mutating étendent les types valeur (struct, enum) et peuvent modifier self. Pour les classes, mutating n’est pas nécessaire. Extension peut ajouter des méthodes mutating même aux types de la bibliothèque standard.

Propriétés calculées dans extension

Extension ne peut ajouter que des propriétés calculées — les propriétés stockées ne sont pas autorisées. C’est logique car extension ne gère pas la mémoire du type d’origine.

extension Date {
    var isPast: Bool {
        return self < Date()
    }

    var isToday: Bool {
        return Calendar.current.isDateInToday(self)
    }
}

let someDate = Date().addingTimeInterval(3600)
print(someDate.isPast) // false (one hour from now is future)

Les propriétés calculées dans extension suivent les mêmes règles que dans l’implémentation principale : on peut créer des propriétés { get } et { get set }. Swift n’impose aucune limite sur le nombre d’extensions pour un type. On peut déclarer autant d’extensions pour un type dans différents fichiers — c’est une pratique standard dans les grands projets.

Conformité aux protocoles via extension

Extension est la façon préférée d’implémenter les protocoles. Au lieu d’encombrer la déclaration principale du type, toutes les méthodes du protocole sont placées dans une extension séparée.

struct User {
    let id: Int
    let name: String
    let email: String
}

// Extension per protocol — clean separation
extension User: Equatable {
    static func == (lhs: User, rhs: User) -> Bool {
        return lhs.id == rhs.id
    }
}

extension User: Codable {
    enum CodingKeys: String, CodingKey {
        case id, name, email
    }
}

Cette approche sépare les responsabilités : la structure principale ne contient que des propriétés stockées, les extensions contiennent les implémentations des protocoles. Swift permet même d’implémenter un protocole via extension pour des types que nous ne contrôlons pas.

Extension et organisation du code

Extension n’est pas seulement une fonctionnalité linguistique mais un outil d’organisation architecturale. L’utilisation correcte des extensions rend le code lisible et maintenable.

• Regroupement par protocole — chaque protocole dans une extension séparée
• Marques (MARK) — // MARK: - Equatable pour la navigation
• Séparation des fichiers — extensions pour différents protocoles dans différents fichiers
• Helpers privés — méthodes privées dans extension marquées private

// MARK: - User + Displayable
extension User: Displayable {
    var displayName: String {
        return "\(name) (\(email))"
    }
}

Selon les Swift API Design Guidelines, les extensions améliorent la lisibilité : le développeur voit la structure de données dans la déclaration principale et la logique dans les extensions. Cela correspond au principe de ségrégation des interfaces.

Extension avec contraintes where ajoute des méthodes uniquement pour des types spécifiques : extension Array where Element: Equatable { func isUnique() -> Bool }. Ce code est concis et type-safe — la méthode isUnique n’apparaît que sur les tableaux avec des éléments Equatable, éliminant les erreurs à la compilation et rendant l’API plus propre, plus sûre et plus claire pour les autres développeurs.