0Pricing
Swift Academy · Leçon

Abstractions fondées sur les protocoles

Dépendez de protocoles plutôt que de types concrets.

Abstractions fondées sur les 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.

Abstractions fondées sur des protocoles

Injecter un protocole plutôt qu’un type concret permet de remplacer librement les implémentations. Le consommateur dépend uniquement du comportement, pas de la classe.

Définir un protocole

Décrivez la capacité sous la forme d’un protocole. Tout type qui s’y conforme peut être fourni comme dépendance.

protocol Logging {
    func log(_ message: String)
}
print("Protocol describes behavior, not a concrete class.")

Faire adopter un protocole à un type concret

Une implémentation réelle adopte le protocole. C’est la dépendance utilisée en production.

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging {
    func log(_ m: String) { print("LOG: \(m)") }
}
ConsoleLogger().log("ready")

Dépendre du protocole

Le type de propriété du consommateur est le protocole : il accepte donc toute valeur conforme.

protocol Logging { func log(_ m: String) }
struct ConsoleLogger: Logging { func log(_ m: String) { print(m) } }
struct Service {
    let logger: Logging // protocol, not ConsoleLogger
    func run() { logger.log("running") }
}
Service(logger: ConsoleLogger()).run()

Remplacer les implémentations

Comme le type est un protocole, vous pouvez transmettre une autre implémentation conforme sans toucher au consommateur.

protocol Logging { func log(_ m: String) }
struct Loud: Logging { func log(_ m: String) { print(m.uppercased()) } }
struct Quiet: Logging { func log(_ m: String) {} }
struct Service { let logger: Logging; func run() { logger.log("hi") } }
Service(logger: Loud()).run()
Service(logger: Quiet()).run()

Programmer contre des interfaces

C’est le principe « dépendre des abstractions, et non des implémentations concrètes ». Le code de haut niveau est protégé des détails de bas niveau.

protocol Storage { func save(_ v: Int) }
struct MemoryStore: Storage { func save(_ v: Int) { print("kept \(v)") } }
struct Manager { let store: Storage; func add() { store.save(1) } }
Manager(store: MemoryStore()).add()

Plusieurs types conformes

Plusieurs types peuvent se conformer au même protocole, chacun étant adapté à un contexte comme le réseau, le disque ou la mémoire.

protocol Source { func value() -> Int }
struct Fixed: Source { func value() -> Int { 10 } }
struct Doubler: Source { func value() -> Int { 20 } }
func use(_ s: Source) { print(s.value()) }
use(Fixed())
use(Doubler())

Protocoles avec comportement associé

Les protocoles peuvent déclarer plusieurs méthodes et former ainsi un contrat clair pour la dépendance.

protocol Cache {
    func get(_ key: String) -> Int?
    func set(_ key: String, _ v: Int)
}
struct Dict: Cache {
    var store: [String: Int] = [:]
    func get(_ k: String) -> Int? { store[k] }
    mutating func set(_ k: String, _ v: Int) { store[k] = v }
}
var c = Dict(); c.set("a", 1)
print(c.get("a") ?? -1)

Contraintes génériques

Vous pouvez également injecter une dépendance au moyen d’un paramètre générique contraint par le protocole, ce qui évite le coût des types existentiels.

protocol Greeter { func greet() -> String }
struct English: Greeter { func greet() -> String { "Hello" } }
struct Welcome<G: Greeter> {
    let greeter: G
    func show() { print(greeter.greet()) }
}
Welcome(greeter: English()).show()

Contrats stables

Tant que le protocole reste stable, les implémentations peuvent changer en interne sans interrompre les consommateurs.

protocol Formatter { func format(_ n: Int) -> String }
struct Plain: Formatter { func format(_ n: Int) -> String { "\(n)" } }
struct Padded: Formatter { func format(_ n: Int) -> String { String(format: "%03d", n) } }
func render(_ f: Formatter) { print(f.format(7)) }
render(Plain())
render(Padded())

Préparer la simulation

Point essentiel, les protocoles permettent aux tests de fournir un type conforme factice à la place du type réel. C’est l’objectif de la prochaine leçon.

protocol Network { func fetch() -> String }
struct Real: Network { func fetch() -> String { "server data" } }
struct VM { let net: Network; func load() { print(net.fetch()) } }
VM(net: Real()).load()

Vérification rapide

Pourquoi injecter un type protocolaire plutôt qu’une classe concrète ?

Récapitulatif

Injecter un protocole masque le type concret : tout type conforme peut donc le remplacer. Cela suit le principe « dépendre des abstractions » et permet d’utiliser d’autres implémentations, notamment des doublures de test. Ensuite : simuler les dépendances dans les tests.

Questions Fréquemment Posées

La leçon « Abstractions fondées sur les protocoles » est-elle gratuite ?

Oui — le texte complet de « Abstractions fondées sur les 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 « Abstractions fondées sur les protocoles » ?

Dépendez de protocoles plutôt que de types concrets. 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 « Abstractions fondées sur les 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

  1. Pourquoi l’injection de dépendances
  2. Injection par constructeur
  3. Abstractions fondées sur les protocoles
  4. Simuler les dépendances dans les tests
← Retour à Swift Academy