Swift Academy · Leçon

Pourquoi l’injection de dépendances

Séparez la construction de l’utilisation pour faciliter les tests.

Pourquoi l’injection de dépendances 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.

Pourquoi l’injection de dépendances

Injection de dépendances (DI) signifie fournir à un objet ce dont il a besoin depuis l’extérieur, au lieu de le laisser créer lui-même ces éléments. Cela découple les composants et facilite leur mise à l’épreuve.

Le problème : couplage fort

Lorsqu’un type construit ses propres collaborateurs, il est lié à ces classes concrètes et ne peut pas être reconfiguré ni mis à l’épreuve isolément.

class Logger {
    func log(_ m: String) { print("LOG: \(m)") }
}
class Service {
    let logger = Logger() // hard-coded dependency
    func run() { logger.log("running") }
}
Service().run()

Le couplage complique les tests

Comme Service crée toujours un véritable Logger, un test ne peut ni intercepter ni simuler la sortie de journalisation. La dépendance est invisible depuis l’extérieur.

class Logger { func log(_ m: String) { print(m) } }
class Service {
    let logger = Logger()
    func run() { logger.log("hello") }
}
// No way to swap Logger here.
Service().run()

L’idée : injecter la dépendance

À la place, transmettez la dépendance. L’appelant décide de l’implémentation à fournir, et Service n’a donc plus à s’en soucier.

class Logger { func log(_ m: String) { print("LOG: \(m)") } }
class Service {
    let logger: Logger
    init(logger: Logger) { self.logger = logger }
    func run() { logger.log("running") }
}
Service(logger: Logger()).run()

Avantages du découplage

Grâce à l’injection, le même Service fonctionne avec différents composants de journalisation, en production comme dans les tests, sans modifier son code.

class Logger { var lines: [String] = []
    func log(_ m: String) { lines.append(m) } }
class Service {
    let logger: Logger
    init(logger: Logger) { self.logger = logger }
    func run() { logger.log("event") }
}
let l = Logger()
Service(logger: l).run()
print(l.lines)

Responsabilité unique

La DI favorise le principe de responsabilité unique : un type se concentre sur sa tâche et délègue les autres préoccupations aux collaborateurs injectés.

struct Mailer { func send(_ to: String) { print("Mail to \(to)") } }
struct SignupFlow {
    let mailer: Mailer
    func register(_ email: String) { mailer.send(email) }
}
SignupFlow(mailer: Mailer()).register("a@b.com")

Flexibilité

Vous pouvez recombiner les objets de nouvelles façons. L’assemblage se fait aux périphéries de votre app, ce qui préserve la flexibilité du cœur.

struct Engine { let power: Int }
struct Car {
    let engine: Engine
    func describe() { print("Power: \(engine.power)") }
}
Car(engine: Engine(power: 200)).describe()
Car(engine: Engine(power: 90)).describe()

Dépendances explicites

Un initialiseur qui énumère ses dépendances documente exactement ce dont le type a besoin. Les dépendances cachées et créées par le type lui-même dissimulent ce contrat.

struct Repo { func load() -> [Int] { [1, 2, 3] } }
struct Report {
    let repo: Repo // visible dependency
    func total() -> Int { repo.load().reduce(0, +) }
}
print(Report(repo: Repo()).total())

Composition plutôt que construction

La DI privilégie la composition des objets depuis l’extérieur. Un petit point central d’assemblage construit le graphe ; le reste du code reçoit simplement ce dont il a besoin.

struct DB { func count() -> Int { 42 } }
struct Stats { let db: DB; func show() { print(db.count()) } }
// Composition root:
let app = Stats(db: DB())
app.show()

Pas seulement pour les grandes applications

Même les petits programmes en tirent profit : injecter une dépendance rend le comportement interchangeable et les intentions claires, sans ajouter de bibliothèque.

struct Clock { func now() -> Int { 12 } }
struct Greeter {
    let clock: Clock
    func greet() { print(clock.now() < 12 ? "Morning" : "Afternoon") }
}
Greeter(clock: Clock()).greet()

Aucun cadre logiciel nécessaire

Avec Swift, la DI ne nécessite aucune bibliothèque. Des initialiseurs simples et des protocoles suffisent. Les prochaines leçons présentent l’injection par constructeur, les protocoles et les simulacres.

struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
    let adder: Adder
    func run() { print(adder.add(2, 3)) }
}
Calc(adder: Adder()).run()

Vérification rapide

Quelle est l’idée fondamentale de l’injection de dépendances ?

Récapitulatif

Injection de dépendances fournit les collaborateurs depuis l’extérieur au lieu de les construire en interne, ce qui réduit le couplage, clarifie les dépendances et permet les tests. Elle ne nécessite aucun cadre logiciel en Swift. Vous allez maintenant découvrir sa forme la plus courante : l’injection par constructeur.

Questions Fréquemment Posées

La leçon « Pourquoi l’injection de dépendances » est-elle gratuite ?

Oui — le texte complet de « Pourquoi l’injection de dépendances » 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 « Pourquoi l’injection de dépendances » ?

Séparez la construction de l’utilisation pour faciliter les tests. 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 « Pourquoi l’injection de dépendances » ?

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

← Retour à Swift Academy