Dependency injection tramite costruttore
Inietti le dipendenze in modo chiaro tramite i costruttori.
Dependency injection tramite costruttore è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.
Iniezione tramite costruttore in dettaglio
L'iniezione tramite costruttore dichiara ogni dipendenza come parametro del costruttore. L'oggetto è completamente configurato nel momento in cui viene creato, perciò è impossibile dimenticare i collaboratori obbligatori.
Proprietà dei parametri
TypeScript può dichiarare e assegnare una dipendenza in un unico passaggio usando un modificatore di accesso sul parametro. private readonly crea e assegna automaticamente il campo.
interface Mailer { send(to: string, body: string): void; }
class Notifier {
constructor(private readonly mailer: Mailer) {}
}Dipendenze basate su interfacce
Dipendere da un'interfaccia anziché da una classe disaccoppia chi la utilizza da qualsiasi implementazione specifica. È possibile fornire qualsiasi oggetto conforme all'interfaccia.
interface Mailer { send(to: string, body: string): void; }
class SmtpMailer implements Mailer {
send(to: string, body: string) { console.log("SMTP ->", to); }
}Configurare le dipendenze nel composition root
Il punto in cui viene creato il grafo degli oggetti è il composition root. Qui si scelgono le implementazioni concrete e le si iniettano.
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");Sostituire le implementazioni
Poiché la dipendenza è un'interfaccia, è possibile fornire un'implementazione completamente diversa senza modificare Notifier. Questa è la flessibilità fondamentale offerta dalla 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"]Testare senza I/O reale
Iniettare il mailer fake consente a un test di verificare ciò che sarebbe stato inviato, senza mandare email reali. Il test è veloce, deterministico e isolato.
const fake = new FakeMailer();
new Notifier(fake).notify("test@site");
console.log(fake.sent.length === 1); // truePiù dipendenze
È possibile elencare tutte le dipendenze necessarie. Ognuna è esplicita, tipizzata e obbligatoria, così le esigenze della classe rimangono immediatamente visibili.
interface Logger { log(m: string): void; }
class Notifier {
constructor(
private readonly mailer: Mailer,
private readonly logger: Logger,
) {}
}readonly impedisce la riassegnazione
Contrassegnare i campi iniettati come readonly impedisce di sostituirli durante il ciclo di vita dell'oggetto, mantenendo stabili e prevedibili i suoi collaboratori.
class Notifier {
constructor(private readonly mailer: Mailer) {}
// this.mailer = ... would be a compile error
}Nessun new nascosto all'interno
Una classe che usa l'iniezione tramite costruttore non dovrebbe creare internamente i propri collaboratori con new. Tutte le dipendenze arrivano tramite il costruttore, mantenendo esplicito l'accoppiamento.
Obbligatorie e facoltative
Le dipendenze obbligatorie appartengono al costruttore. Quelle veramente facoltative possono usare come valore predefinito un'implementazione no-op, che viene comunque passata dall'esterno anziché costruita all'interno.
const noopLogger: Logger = { log() {} };
new Notifier(new SmtpMailer(), noopLogger);Riepilogo dei vantaggi
L'iniezione tramite costruttore rende esplicite le dipendenze, gli oggetti completamente inizializzati, le implementazioni sostituibili e i test semplici. È lo stile DI predefinito per una buona ragione.
Verifica rapida
Una breve verifica su questa lezione.
Riepilogo
L'iniezione tramite costruttore dichiara le dipendenze come parametri, spesso private readonly, tipizzati tramite un'interfaccia. Il composition root sceglie le implementazioni e i test passano fake. Gli oggetti sono sempre completamente configurati e i collaboratori possono essere sostituiti senza modificare la classe.
Domande Frequenti
La lezione «Dependency injection tramite costruttore» è gratuita?
Sì — il testo completo di «Dependency injection tramite costruttore» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.
Cosa imparerò in «Dependency injection tramite costruttore»?
Inietti le dipendenze in modo chiaro tramite i costruttori. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.
Quanto tempo richiede la lezione «Dependency injection tramite costruttore»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Basi dell’inversione del controllo
- Dependency injection tramite costruttore
- Container DI con InversifyJS
- Token di servizio type-safe