Extensions en Swift : comment améliorer son code iOS

Tu travailles sur un gros projet et tu veux implémenter des fonctions propres à certains protocoles ? Tu voudrais qu’il existe une fonction licorne qui permet de colorer ton texte avec un arc-en-ciel ? Je vais te montrer que tu peux faire ce genre de choses avec les extensions en Swift.

Comprendre les extensions en Swift 

Les extensions ajoutent de nouvelles fonctionnalités à une classe, une structure, une énumération ou un type de protocole existant.

Elles permettent notamment d’étendre des types pour lesquels tu n’as pas accès au code source d’origine. Les extensions sont similaires aux catégories en Objective-C. Mais contrairement aux catégories de l’Objective-C, les extensions Swift n’ont pas de nom.

Elles permettent de :

• Définir de nouvelles méthodes
• Ajouter des propriétés
• Définir et utiliser de nouveaux types imbriqués
• Rendre un type existant conforme à un protocole
• Etendre des types natifs ou personnalisés
• Organiser le code

💡 Bien que les extensions en Swift soient très utiles, il est important de noter qu’elles ne peuvent pas ajouter de nouvelles propriétés stockées ou modifier l’implémentation existante d’un type.

→ Les extensions ne peuvent que fournir de nouvelles fonctionnalités en utilisant les propriétés et les méthodes existantes.

Pour vulgariser, imagine que Swift est un grand parc rempli d’oiseaux de toutes sortes. Chaque oiseau représente un type de base dans Swift, comme les chaînes de caractères, les tableaux, ou même les classes et les structures que tu crées.

Maintenant, les extensions sont comme des petits oiseaux autour de l’oiseau principal. Chaque petit oiseau représente une extension différente.

L’idée géniale des extensions en Swift, c’est que tu peux ajouter plein de petits oiseaux annexes sans avoir à modifier l’oiseau d’origine. Cela signifie que tu peux garder le code de base propre et intact, tout en étendant ses fonctionnalités de manière modulaire. Les extensions te permettent d’organiser ton code de manière logique. Par exemple, tu peux regrouper toutes les extensions liées au chant des oiseaux ensemble, et celles qui concernent leur danse dans un autre groupe. Cela rend le code plus facile à lire et à comprendre.

En Swift, tu peux également étendre un protocole pour fournir des implémentations ou ajouter des fonctionnalités supplémentaires. Pour plus de détails sur ce sujet, tu peux jeter un coup d’oeil à la documentation officielle sur les extensions de protocole.

Syntaxe

Pour déclarer une extension :

extension SomeNamedType {
    // ajouter les fonctionnalités
}

Etendre les fonctionnalités de Swift & SwiftUI

• Etendre les types natifs

Si tu as bien lu, tu as compris que tu pouvais rajouter des fonctions aux types natifs de Swift. Prenons l’exemple du type String. Nous allons l’étendre en créant une fonction qui transformera la première lettre du mot sur laquelle elle est appliquée, en majuscule.

extension String {
    // Création de la nouvelle fonction du type String
    func capitalizeFirstLetter() -> String {
        return prefix(1).capitalized + dropFirst()
    }
}

let myString = "hello"
print(myString.capitalizeFirstLetter()) // Affiche "Hello"

Pour un ajout de nouvelles propriétés, prenons l’exemple du type Int. Nous lui rajoutons la propriété isEven, pour savoir si le nombre est pair :

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}

let myNumber = 10
print(myNumber.isEven) // Affiche "true"

• Etendre un protocole

Les extensions peuvent être utilisées pour ajouter des implémentations par défaut aux méthodes d’un protocole. Cela permet de fournir une implémentation commune à plusieurs types différents, simplifiant ainsi la conformité au protocole.

protocol Printable {
    func printDetails()
}

extension Printable {
    func printDetails() {
        print("Détails non disponibles")
    }
}

struct Person: Printable {
    var name: String
    // ...
}

let person = Person(name: "John Doe")
person.printDetails() // Affiche "Détails non disponibles"

• Etendre une structure

Même principe que pour les protocoles. Ici, on lui créé une nouvelle fonction greet().

struct Person {
    var name: String
    var age: Int
}

extension Person {
    func greet() {
        print("Bonjour, je m'appelle \(name)!")
    }
}

extension Person {
    var isAdult: Bool {
        return age >= 18
    }
}

let person = Person(name: "Alice", age: 25)
person.greet() // Affiche "Bonjour, je m'appelle Alice!"
print(person.isAdult) // Affiche "true"

Bonnes pratiques des extensions en Swift

• Cohérence et lisibilité :
  • Nomme tes extensions de manière descriptive pour indiquer clairement leur but et leur fonctionnalité.
  • Divise les extensions de manière logiques en regroupant les fonctionnalités. Cela facilite la navigation et la recherche de code.

• Responsabilité unique :
  • Les extensions doivent se concentrer sur une seule fonctionnalité ou un seul aspect d’un type. Attention à ne pas surcharger une extension avec trop de méthodes ou de propriétés.
  • Si tu as besoin d’étendre un type avec plusieurs fonctionnalités distinctes, sépare-les en extensions distinctes pour maintenir une organisation claire et faciliter la réutilisation.

• Éviter les modifications de l’implémentation existante :
  • Elles ne doivent pas être utilisées pour pour ça donc pense aux méthodes et au comportement actuel du type avant d’implémenter son extension → Privilégie l’ajout de nouvelles fonctionnalités ou la modification des comportements via de nouvelles méthodes ou propriétés.

• Étendre des types spécifiques plutôt que des types génériques :
  • Il vaut mieux étendre des types spécifiques plutôt que des types génériques tels que Array, Dictionary, etc. Cela permet d’éviter d’ajouter des fonctionnalités inappropriées à des types qui peuvent être utilisés dans divers contextes.

• Fonctionnalités partagées :
  • Utilise les protocoles pour regrouper des fonctionnalités partagées plutôt que de les étendre directement. Les extensions peuvent ensuite être appliquées aux types conformes au protocole, facilitant ainsi la réutilisation du code.

• Ordre de chargement des extensions :
  • Garde à l’esprit que l’ordre dans lequel les extensions sont chargées peut être important lorsque des fonctionnalités ou des noms se chevauchent. Cela prévient ainsi les risques de conflits !

• Teste et documente :
  • Comme pour tout code, teste soigneusement tes extensions pour t’assurer de leur bon fonctionnement et de leur compatibilité avec d’autres parties du code.
  • N’hésite pas à rédiger une documentation claire et concise pour décrire l’utilisation et les fonctionnalités de tes extensions, afin que les autres développeurs puissent les comprendre et les utiliser correctement.

---

Voilà, tu en sais un peux plus sur les extensions. Lance toi maintenant et joues avec elles, c’est le meilleur moyen de les comprendre.

Et dis nous en commentaire quelle sera ta première extension ! 🫶