Injection par constructeur
Injecter proprement les dépendances par l’intermédiaire des constructeurs.
Injection par constructeur est une leçon TypeScript 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 TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
L’injection par constructeur en détail
L’injection par constructeur déclare chaque dépendance comme paramètre du constructeur. L’objet est entièrement câblé dès sa création, ce qui rend impossible l’oubli de collaborateurs obligatoires.
Propriétés de paramètres
TypeScript peut déclarer et affecter une dépendance en une seule étape en utilisant un modificateur d’accès sur le paramètre. private readonly crée et affecte automatiquement le champ.
interface Mailer { send(to: string, body: string): void; }
class Notifier {
constructor(private readonly mailer: Mailer) {}
}Dépendances fondées sur des interfaces
Dépendre d’une interface plutôt que d’une classe découple le consommateur de toute implémentation particulière. Tout objet correspondant à l’interface peut être fourni.
interface Mailer { send(to: string, body: string): void; }
class SmtpMailer implements Mailer {
send(to: string, body: string) { console.log("SMTP ->", to); }
}Câblage à la racine de composition
L’endroit qui crée le graphe d’objets est la racine de composition. C’est là que vous choisissez les implémentations concrètes et que vous les injectez.
class Notifier {
constructor(private readonly mailer: Mailer) {}
notify(to: string) { this.mailer.send(to, "hello"); }
}
const app = new Notifier(new SmtpMailer());
app.notify("a@b.com");Remplacer les implémentations
Comme la dépendance est une interface, vous pouvez fournir une implémentation totalement différente sans toucher à Notifier. C’est la flexibilité fondamentale qu’offre DI.
class FakeMailer implements Mailer {
sent: string[] = [];
send(to: string) { this.sent.push(to); }
}
const fake = new FakeMailer();
new Notifier(fake).notify("x@y.com");
console.log(fake.sent); // ["x@y.com"]Tester sans véritables entrées-sorties
L’injection du service de courrier factice permet à un test de vérifier ce qui aurait été envoyé, sans envoyer de véritable courriel. Le test est rapide, déterministe et isolé.
const fake = new FakeMailer();
new Notifier(fake).notify("test@site");
console.log(fake.sent.length === 1); // truePlusieurs dépendances
Répertoriez autant de dépendances que nécessaire. Chacune est explicite, typée et obligatoire, ce qui rend les besoins de la classe visibles en un coup d’œil.
interface Logger { log(m: string): void; }
class Notifier {
constructor(
private readonly mailer: Mailer,
private readonly logger: Logger,
) {}
}readonly empêche la réaffectation
Le marquage des champs injectés avec readonly empêche leur remplacement au cours de la durée de vie de l’objet, ce qui stabilise et rend prévisibles ses collaborateurs.
class Notifier {
constructor(private readonly mailer: Mailer) {}
// this.mailer = ... would be a compile error
}Aucun new caché à l’intérieur
Une classe utilisant l’injection par constructeur ne doit pas créer elle-même ses collaborateurs avec new. Toutes les dépendances arrivent par le constructeur, ce qui rend le couplage explicite.
Obligatoire ou facultatif
Les dépendances obligatoires doivent figurer dans le constructeur. Les dépendances véritablement facultatives peuvent utiliser par défaut une implémentation sans opération, qui est tout de même transmise plutôt que construite à l’intérieur.
const noopLogger: Logger = { log() {} };
new Notifier(new SmtpMailer(), noopLogger);Résumé des avantages
L’injection par constructeur rend les dépendances explicites, les objets entièrement initialisés, les implémentations interchangeables et les tests très simples. C’est le style DI utilisé par défaut, à juste titre.
Vérification rapide
Vérification rapide de cette leçon.
Récapitulatif
L’injection par constructeur déclare les dépendances comme paramètres, souvent private readonly, typés par une interface. La racine de composition choisit les implémentations ; les tests transmettent des implémentations factices. Les objets sont toujours entièrement câblés et les collaborateurs peuvent être remplacés sans modifier la classe.
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 TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Injection par constructeur » ?
Injecter proprement les dépendances par l’intermédiaire des constructeurs. Tu pratiques TypeScript 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 TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript 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 TypeScript Academy ?
Oui. Chaque leçon TypeScript 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
- Principes de l’inversion de contrôle
- Injection par constructeur
- Conteneurs DI avec InversifyJS
- Jetons de service sûrs du point de vue du typage