Swift Academy · Leçon

Principes de conception orientée protocole

Privilégier la composition de protocoles à l’héritage de classes pour une conception flexible.

Principes de conception orientée protocole est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

La programmation orientée protocoles (POP) privilégie la composition de protocoles à l’héritage de classes afin de créer du code Swift flexible, vérifiable et réutilisable.

Le problème de l’héritage

Les hiérarchies de classes profondes posent plusieurs problèmes : • Les sous-classes héritent de TOUT l’état et de tout le comportement de la super-classe • Modifier une super-classe peut casser ses sous-classes • Il est impossible d’hériter de deux classes Les protocoles résolvent ces trois problèmes.

Commencer par un protocole

```swift protocol Greetable { var greeting: String { get } func greet() } extension Greetable { func greet() { print(greeting) } // default implementation } ``` Les extensions de protocoles fournissent des implémentations par défaut dont bénéficie gratuitement tout type conforme.

Composer des comportements

```swift protocol Persistable { func save() } protocol Networked { func fetch() async throws -> Data } protocol Loggable { func log(_ msg: String) } struct DataService: Persistable, Networked, Loggable { ... } ``` Combinez les comportements comme des briques LEGO — aucune hiérarchie de classes n’est nécessaire.

Extensions de protocoles pour une logique partagée

```swift extension Loggable { func log(_ msg: String) { print("[\(type(of: self))] \(msg)") } } // Every Loggable type gets this for free ```

Modélisation rétroactive

Les protocoles peuvent être appliqués à des types qui ne vous appartiennent pas : ```swift protocol JSONConvertible { func toJSON() -> String } extension Int: JSONConvertible { func toJSON() -> String { "\(self)" } } ``` Ajoutez des conformités aux types de la bibliothèque standard sans créer de sous-classes.

Types valeur + protocoles

Les structures conformes à des protocoles vous offrent à la fois une sémantique de valeur *et* le polymorphisme : ```swift protocol Shape { var area: Double { get } } struct Circle: Shape { var radius: Double; var area: Double { .pi * radius * radius } } struct Square: Shape { var side: Double; var area: Double { side * side } } let shapes: [any Shape] = [Circle(radius:3), Square(side:4)] shapes.map { $0.area } // [28.27, 16] ```

Injection de dépendances par protocole

```swift protocol DataStore { func save(_ data: Data) } struct FileStore: DataStore { func save(_ d: Data) { /* disk */ } } struct MockStore: DataStore { func save(_ d: Data) { /* test log */ } } class Service { let store: DataStore init(store: DataStore) { self.store = store } } ```

Quand utiliser des classes

Privilégiez les classes lorsque : • vous avez besoin d’un état mutable partagé (sémantique de référence) • vous devez intégrer des API ObjC/UIKit • l’héritage constitue le modèle approprié (rare) Dans tous les autres cas, privilégiez par défaut les protocoles et les structures.

Conventions de nommage des protocoles

• Protocoles de capacité : suffixes `-able`, `-ible` et `-ing` (Equatable, Hashable, Coding) • Protocoles de délégué : suffixe `Delegate` ou `DataSource` • Rôle abstrait : nom (`Store`, `Parser`, `Renderer`) De bons noms rendent le code orienté protocoles explicite par lui-même.

Vérification rapide

Que fournissent les extensions de protocoles aux types conformes ?

Récapitulatif

Points essentiels : • Préférez les protocoles et les structures aux hiérarchies de classes • Les extensions de protocoles fournissent des implémentations par défaut partagées • Composez les comportements à partir de petits protocoles à usage unique • Les protocoles permettent l’injection de dépendances pour faciliter les vérifications • Réservez les classes à la sémantique de référence et à l’interopérabilité avec ObjC Cours terminé ! Ensuite : étude approfondie des types valeur et des types référence.

Questions Fréquemment Posées

La leçon « Principes de conception orientée protocole » est-elle gratuite ?

Oui — le texte complet de « Principes de conception orientée protocole » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Principes de conception orientée protocole » ?

Privilégier la composition de protocoles à l’héritage de classes pour une conception flexible. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Principes de conception orientée protocole » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Composition de protocoles avec &
Conformité conditionnelle
Exigences Self et conception avec Equatable
Principes de conception orientée protocole

← Retour à Swift Academy