Composition de protocoles
Combinez plusieurs exigences de protocoles avec &.
Composition de protocoles est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Combiner des protocoles
Il arrive qu'une valeur doive satisfaire plusieurs protocoles à la fois. Swift permet de composer des protocoles avec l'opérateur & : SomeProtocol & AnotherProtocol.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }Un paramètre composé
Un paramètre typé Named & Aged accepte toute valeur conforme aux deux protocoles.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged {
let name: String
let age: Int
}
func intro(_ x: Named & Aged) {
print(x.name + " is " + String(x.age))
}
intro(Person(name: "Sam", age: 28))Pourquoi pas l'héritage ?
La composition permet d'exiger les deux protocoles au moment de l'appel sans créer de nouveau protocole combiné. Elle conserve aux protocoles une taille réduite et une bonne réutilisabilité.
protocol Drawable { func draw() -> String }
protocol Resizable { func resize(_ f: Double) -> String }
struct Icon: Drawable, Resizable {
func draw() -> String { "drawing" }
func resize(_ f: Double) -> String { "x" + String(f) }
}
func render(_ v: Drawable & Resizable) {
print(v.draw(), v.resize(2))
}
render(Icon())Trois protocoles ou plus
Vous pouvez enchaîner autant de protocoles que nécessaire avec des opérateurs & supplémentaires.
protocol A { func a() -> String }
protocol B { func b() -> String }
protocol C { func c() -> String }
struct X: A, B, C {
func a() -> String { "a" }
func b() -> String { "b" }
func c() -> String { "c" }
}
func use(_ v: A & B & C) { print(v.a(), v.b(), v.c()) }
use(X())Composition avec une classe
Vous pouvez combiner un type classe avec des protocoles : SomeClass & SomeProtocol exige que la valeur soit une instance de cette classe ou d'une sous-classe AND qu'elle soit conforme au protocole.
class Vehicle { var speed = 0 }
protocol Electric { var battery: Int { get } }
class Tesla: Vehicle, Electric { var battery = 100 }
func check(_ v: Vehicle & Electric) {
print(v.speed, v.battery)
}
check(Tesla())Renvoyer une composition
Une fonction peut renvoyer un type composé, en promettant à l'appelant que le résultat est conforme à tous les protocoles indiqués.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged { let name: String; let age: Int }
func makePerson() -> Named & Aged {
Person(name: "Eve", age: 22)
}
let p = makePerson()
print(p.name, p.age)typealias pour une composition
Donnez un nom lisible à une composition avec typealias afin de pouvoir la réutiliser sans répéter la chaîne de &.
protocol Codable2 { func encode() -> String }
protocol Loggable { func log() -> String }
typealias Persistable = Codable2 & Loggable
struct Record: Persistable {
func encode() -> String { "data" }
func log() -> String { "logged" }
}
func save(_ r: Persistable) { print(r.encode(), r.log()) }
save(Record())Composition dans les collections
Vous pouvez stocker des valeurs de type composé dans des tableaux et accéder aux membres de tous les protocoles pour chaque élément.
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct P: Named, Aged { let name: String; let age: Int }
let group: [Named & Aged] = [P(name: "A", age: 1), P(name: "B", age: 2)]
for g in group { print(g.name, g.age) }Composition avec des protocoles standard
La composition est particulièrement utile avec les protocoles de bibliothèque. Vous pouvez par exemple exiger à la fois CustomStringConvertible et Equatable.
func report<T>(_ items: [T]) where T: CustomStringConvertible & Equatable {
for i in items { print(i.description) }
}
report([1, 2, 3])Les protocoles vides comme marqueurs
La composition peut associer un protocole marqueur (sans exigences) à un protocole fonctionnel pour exprimer une intention dans le système de types.
protocol Secure {}
protocol Sendable2 { func send() -> String }
struct Packet: Secure, Sendable2 {
func send() -> String { "sent securely" }
}
func transmit(_ p: Secure & Sendable2) { print(p.send()) }
transmit(Packet())Composition et types génériques
La composition (A & B) efface le type concret ; les types génériques (<T: A & B>) le préservent. Utilisez les types génériques lorsque vous devez relier les types des paramètres et de la valeur de retour.
protocol A { func a() -> String }
protocol B { func b() -> String }
struct S: A, B { func a() -> String { "a" }; func b() -> String { "b" } }
func generic<T: A & B>(_ x: T) -> T { print(x.a(), x.b()); return x }
_ = generic(S())Vérification rapide
Évaluez votre compréhension de la composition de protocoles.
Récapitulatif
La composition de protocoles avec & vous permet d'exiger la conformité à plusieurs protocoles (et éventuellement à une classe) à la fois, sans définir de nouveau protocole combiné. Vous pouvez nommer les compositions avec typealias, les utiliser pour les paramètres, les valeurs de retour et les collections, et vous avez vu en quoi la composition se distingue des types génériques pour préserver les types concrets.
Questions Fréquemment Posées
La leçon « Composition de protocoles » est-elle gratuite ?
Oui — le texte complet de « Composition de protocoles » 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 » ?
Combinez plusieurs exigences de protocoles avec &. 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 3 sur 4.
Combien de temps prend la leçon « Composition de protocoles » ?
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
- Les protocoles comme contrats
- Implémentations par défaut dans les extensions
- Composition de protocoles
- Conformité conditionnelle