Swift Academy · Leçon

Composition de protocoles avec &

Combiner plusieurs protocoles en une seule exigence de type.

Leçon 1 sur 412 étapes

Composition de protocoles avec & est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 composition de protocoles permet de combiner plusieurs protocoles en une seule exigence de type à l'aide de `&`. C'est la réponse de Swift à l'héritage multiple.

Composition de base

```swift protocol Named { var name: String { get } } protocol Aged { var age: Int { get } } func describe(_ entity: Named & Aged) { print("\(entity.name) is \(entity.age)") } ``` `Named & Aged` est une exigence de type temporaire, et non un nouveau protocole.

Utilisation dans les paramètres de fonction

```swift protocol Drawable { func draw() } protocol Animatable { func animate() } func render(_ view: Drawable & Animatable) { view.draw() view.animate() } ```

Stocker des types composés

```swift var entity: Named & Aged = makePerson() entity.name // accessible entity.age // accessible ``` Le type de la variable détermine les membres des protocoles auxquels vous pouvez accéder.

Composition avec des classes

```swift protocol Configurable { func configure() } func setup(_ vc: T) { vc.configure() present(vc, animated: true) } ``` Combinez une exigence de classe avec un protocole à l'aide de `&` dans les types génériques.

Composition de protocoles ou nouveau protocole

```swift // Don't create a new protocol just to combine: protocol NamedAndAged: Named, Aged {} // often unnecessary // Prefer inline composition at use sites: func describe(_ e: Named & Aged) { } ``` Les nouveaux protocoles ne sont utiles que lorsque la combinaison nécessite des méthodes d'extension.

typealias pour les compositions longues

```swift typealias Service = Authenticable & Cacheable & Loggable func process(service: Service) { service.authenticate() service.log("processing") } ``` Utilisez `typealias` pour donner un nom aux compositions couramment utilisées.

Composition dans les contraintes génériques

```swift func fetchAndCache(_ resource: T) async throws { let data = try await resource.fetch() resource.cache(data) } ```

Héritage de protocoles ou composition

• Héritage : `protocol C: A, B {}` — C hérite de toutes les exigences de A et B • Composition : `A & B` — en ligne, sans nouveau type Utilisez l'héritage lorsque tous les types conformes doivent respecter les deux protocoles ; utilisez la composition sur les sites d'appel.

Exemple concret : délégué + DataSource

```swift func setup(_ vc: UITableViewDelegate & UITableViewDataSource) { tableView.delegate = vc tableView.dataSource = vc } ``` Un seul contrôleur de vue satisfait souvent les deux protocoles ; la composition permet de l'exprimer de manière concise.

Vérification rapide

Quel opérateur combine plusieurs protocoles en une seule exigence de type ?

Réponds-y dans la leçon interactive

Récapitulatif

Points essentiels : • `Protocol1 & Protocol2` — composition en ligne • Utilisez-la dans les paramètres, les types de retour et les contraintes génériques • `typealias` donne un nom aux compositions utilisées fréquemment • Préférez la composition à la création de protocoles vides • Vous pouvez mélanger des exigences de classe : `UIViewController & MyProtocol` Ensuite : la conformité conditionnelle.

Gratuit pour commencer

Apprends Swift avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 122
Leçons: 409

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Composition de protocoles avec & » est-elle gratuite ?

Oui — le texte complet de « Composition de protocoles avec & » 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 « Composition de protocoles avec & » ?

Combiner plusieurs protocoles en une seule exigence de type. 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 1 sur 4.

Combien de temps prend la leçon « Composition de protocoles avec & » ?

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