Swift Academy · Leçon

Injection par constructeur

Transmettez les dépendances par les initialiseurs.

Injection par constructeur est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Injection par constructeur

Le style de DI le plus courant consiste à transmettre les dépendances par un initialiseur. L’objet reçoit tout ce dont il a besoin lors de sa création et le stocke.

Un initialiseur de base

Déclarez une propriété stockée et affectez-lui une valeur dans init. Les appelants doivent fournir la dépendance pour créer l’objet.

struct Greeter { func hi() -> String { "Hi" } }
struct View {
    let greeter: Greeter
    init(greeter: Greeter) { self.greeter = greeter }
    func show() { print(greeter.hi()) }
}
View(greeter: Greeter()).show()

Dépendances immuables

Utiliser let pour les propriétés injectées les rend immuables : une dépendance ne peut donc pas être remplacée après la construction.

struct Engine { let hp: Int }
struct Car {
    let engine: Engine // cannot change later
    init(engine: Engine) { self.engine = engine }
}
let c = Car(engine: Engine(hp: 150))
print(c.engine.hp)

Plusieurs dépendances

Énumérez plusieurs paramètres pour injecter plusieurs collaborateurs. L’initialiseur documente l’ensemble des exigences.

struct DB { func get() -> Int { 7 } }
struct Cache { func put(_ v: Int) { print("cached \(v)") } }
struct Service {
    let db: DB
    let cache: Cache
    init(db: DB, cache: Cache) { self.db = db; self.cache = cache }
    func run() { cache.put(db.get()) }
}
Service(db: DB(), cache: Cache()).run()

Valeurs par défaut des paramètres

Une valeur par défaut permet aux appelants d’omettre une dépendance en production tout en autorisant son remplacement dans les tests.

struct Logger { func log(_ m: String) { print(m) } }
struct Service {
    let logger: Logger
    init(logger: Logger = Logger()) { self.logger = logger }
    func run() { logger.log("go") }
}
Service().run() // uses default

Injection par constructeur de classe

Les classes suivent le même modèle. L’initialiseur affecte chaque dépendance avant que l’instance puisse être utilisée.

class Mailer { func send() { print("sent") } }
class Signup {
    let mailer: Mailer
    init(mailer: Mailer) { self.mailer = mailer }
    func go() { mailer.send() }
}
Signup(mailer: Mailer()).go()

Injecter des valeurs

Les dépendances ne sont pas nécessairement des objets. Vous pouvez injecter de la même façon des valeurs de configuration, comme une URL de base ou un indicateur.

struct Client {
    let baseURL: String
    init(baseURL: String) { self.baseURL = baseURL }
    func endpoint(_ p: String) -> String { baseURL + p }
}
print(Client(baseURL: "https://api").endpoint("/users"))

Point central d’assemblage

Un seul endroit, proche du point d’entrée de l’app, relie tout le graphe d’objets. Tout le reste reçoit simplement des dépendances déjà préparées.

struct DB { func count() -> Int { 3 } }
struct Repo { let db: DB; func n() -> Int { db.count() } }
struct App { let repo: Repo; func run() { print(repo.n()) } }
// Composition root:
let app = App(repo: Repo(db: DB()))
app.run()

Éviter les variables globales cachées

L’injection par constructeur remplace l’accès caché aux variables globales. Chaque dépendance est explicite, ce qui permet de suivre la circulation des données.

struct Settings { let theme: String }
struct Screen {
    let settings: Settings
    func render() { print("Theme: \(settings.theme)") }
}
Screen(settings: Settings(theme: "dark")).render()

Obligatoire ou facultatif

Si une dépendance est réellement facultative, modélisez-la avec un type facultatif ; sinon, rendez-la obligatoire afin qu’un objet ne puisse jamais exister dans un état partiellement configuré.

struct Analytics { func track() { print("tracked") } }
struct Flow {
    let analytics: Analytics?
    func step() { analytics?.track() }
}
Flow(analytics: Analytics()).step()
Flow(analytics: nil).step()

Pourquoi l’injection par constructeur

Elle garantit un objet entièrement initialisé, rend les dépendances visibles et fonctionne avec l’immuabilité de let. C’est le choix recommandé par défaut en Swift.

struct Adder { func add(_ a: Int, _ b: Int) -> Int { a + b } }
struct Calc {
    let adder: Adder
    init(adder: Adder) { self.adder = adder }
}
print(Calc(adder: Adder()).adder.add(4, 5))

Vérification rapide

Pourquoi l’injection par constructeur est-elle souvent privilégiée ?

Récapitulatif

L’injection par constructeur transmet les dépendances par init et les stocke, généralement dans des propriétés let immuables. Vous pouvez injecter des objets ou des valeurs, fournir des valeurs par défaut et tout relier dans un point central d’assemblage. Vous allez maintenant injecter des protocoles plutôt que des types concrets.

Questions Fréquemment Posées

La leçon « Injection par constructeur » est-elle gratuite ?

Oui — le texte complet de « Injection par constructeur » 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 « Injection par constructeur » ?

Transmettez les dépendances par les initialiseurs. 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 2 sur 4.

Combien de temps prend la leçon « Injection par constructeur » ?

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