Basisprincipes van inversion of control
Begrijp waarom en wanneer u afhankelijkheden omkeert
Basisprincipes van inversion of control is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.
Hardgecodeerde afhankelijkheden
Wanneer een klasse haar eigen samenwerkende objecten met new maakt, is ze sterk gekoppeld aan die concrete typen. Daardoor is de klasse moeilijk opnieuw te configureren en moeilijk te testen.
Een sterk gekoppeld voorbeeld
Hier bouwt de service haar eigen logger. Je kunt geen andere logger gebruiken zonder de klasse aan te passen.
class ConsoleLogger { log(m: string) { console.log(m); } }
class OrderService {
private logger = new ConsoleLogger(); // hard-coded
place() { this.logger.log("order placed"); }
}
new OrderService().place();Wat is inversie van controle?
Inversie van controle (IoC) draait om wie over afhankelijkheden beslist. In plaats van dat een klasse ze zelf maakt, levert iets van buitenaf ze aan. De klasse verklaart wat ze nodig heeft en ontvangt dat.
Afhankelijkheidsinjectie
Afhankelijkheidsinjectie (DI) is de gebruikelijke manier om IoC te bereiken: geef samenwerkende objecten door in plaats van ze intern te maken. De aanroeper bepaalt welke implementatie wordt gebruikt.
De geïnjecteerde versie
De logger wordt nu van buitenaf aangeleverd. De service weet niet meer welke concrete logger ze heeft ontvangen en dat maakt haar ook niet uit.
class OrderService {
constructor(private logger: { log(m: string): void }) {}
place() { this.logger.log("order placed"); }
}
new OrderService(new ConsoleLogger()).place();Waarom IoC testen eenvoudiger maakt
Omdat afhankelijkheden van buitenaf komen, kunnen testen testdubbels of observatieobjecten meegeven. Je kunt gedrag controleren zonder echte I/O, databases of netwerkoproepen.
const calls: string[] = [];
const fakeLogger = { log: (m: string) => calls.push(m) };
new OrderService(fakeLogger).place();
console.log(calls); // ["order placed"]Afhankelijk zijn van abstracties
IoC werkt het best wanneer klassen afhankelijk zijn van een interface in plaats van een concrete klasse. Elke implementatie die aan de interface voldoet, kan worden geïnjecteerd.
interface Logger { log(m: string): void; }
class OrderService {
constructor(private logger: Logger) {}
}Injectie via de constructor
Injectie via de constructor geeft afhankelijkheden door als constructorparameters. Ze zijn meteen beschikbaar en kunnen als readonly worden gemarkeerd, waardoor ze duidelijk en verplicht zijn.
class OrderService {
constructor(private readonly logger: Logger) {}
}Injectie via een eigenschap
Injectie via een eigenschap stelt na het maken een afhankelijkheid in op een openbare of instelbare eigenschap. Dit is flexibeler, maar maakt het mogelijk dat het object tijdelijk zonder die afhankelijkheid bestaat.
class OrderService {
logger!: Logger; // set after construction
place() { this.logger.log("placed"); }
}
const s = new OrderService();
s.logger = new ConsoleLogger();Een stijl kiezen
Gebruik bij voorkeur injectie via de constructor voor verplichte afhankelijkheden, omdat het object nooit half opgebouwd is. Gebruik injectie via een eigenschap voor optionele samenwerkende objecten of om constructiecycli te doorbreken.
Vooruitblik op IoC-containers
Bij grote apps wordt het handmatig koppelen van afhankelijkheden al snel vervelend. Een IoC-container automatiseert het maken en aanleveren van afhankelijkheden. In de volgende lessen verken je dit met InversifyJS.
Korte controle
Korte controle van deze les.
Samenvatting
Inversie van controle verplaatst het maken van afhankelijkheden buiten de klasse; afhankelijkheidsinjectie levert ze aan. Werk met interfaces, geef voor verplichte afhankelijkheden de voorkeur aan injectie via de constructor en maak testen eenvoudig door testdubbels te injecteren.
Leer TypeScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 101
- Lessen
- 352
Veelgestelde vragen
Is de les “Basisprincipes van inversion of control” gratis?
Ja — de volledige tekst van “Basisprincipes van inversion of control” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.
Wat leer ik in “Basisprincipes van inversion of control”?
Begrijp waarom en wanneer u afhankelijkheden omkeert Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met TypeScript Academy te beginnen?
Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Basisprincipes van inversion of control”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?
Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Basisprincipes van inversion of control
- Constructorinjectie
- DI-containers met InversifyJS
- Typeveilige servicetokens