TypeScript Academy · Les

Generieke beperkingen met extends

Beperk typeparameters tot specifieke structuren.

Les 3 van 413 stappen

Generieke beperkingen met extends is een gratis TypeScript Academy-les op CoddyKit. Dit is les 3 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.

Welkom

Beperkingen voor generieke typen beperken welke typen als typeargumenten kunnen worden doorgegeven. Gebruik `extends` om te vereisen dat T bepaalde eigenschappen heeft of aan een bepaalde vorm voldoet.

Het probleem zonder beperkingen

Zonder beperkingen weet TypeScript niet welke bewerkingen geldig zijn voor T. Daarom staat het alleen bewerkingen toe die voor alle typen gelden.

function getLength<T>(val: T): number {
  // return val.length; // Error — T might not have .length
}

Een beperking toevoegen

Gebruik `T extends Shape` om te vereisen dat T ten minste de eigenschappen van Shape heeft.

function getLength<T extends { length: number }>(val: T): number {
  return val.length;
}
getLength('hello');  // OK — string has .length
getLength([1, 2]);   // OK — array has .length
// getLength(42);   // Error — number has no .length

Beperken tot een interface

Beperk T tot een specifieke interface die het moet implementeren.

interface Named { name: string; }
function greet<T extends Named>(person: T): string {
  return 'Hello, ' + person.name;
}

De keyof-beperking

Gebruik `K extends keyof T` om K te beperken tot de sleutels van T. Zo wordt veilige toegang tot eigenschappen mogelijk.

function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const age = getProperty({ name: 'Alice', age: 30 }, 'age'); // number

Beperken tot een unietype

T kan worden beperkt tot een unietype, waardoor het typeargument wordt beperkt tot specifieke waarden.

type Status = 'active' | 'inactive' | 'banned';
function setStatus<T extends Status>(status: T): void {
  console.log('Setting status:', status);
}

Beperken tot een constructor

Beperk T tot een klasse (met een constructor), zodat je binnen de functie instanties kunt maken.

function create<T>(ctor: new () => T): T {
  return new ctor();
}

Meerdere beperkingen met een doorsnede

Beperk T zodat het aan meerdere interfaces voldoet met behulp van een doorsnede.

interface Serializable { serialize(): string; }
interface Loggable { log(): void; }
function process<T extends Serializable & Loggable>(item: T): void {
  item.log();
  console.log(item.serialize());
}

Overerving van beperkingen

Beperkingen werken met overerving. Als T een basisklasse uitbreidt, kun je alle methoden van de basisklasse aanroepen.

class Animal { breathe() { return 'breathing'; } }
function care<T extends Animal>(a: T): string { return a.breathe(); }

T breidt zichzelf uit (recursief)

Beperkingen kunnen naar zichzelf verwijzen voor recursieve datastructuren.

interface Comparable<T> { compareTo(other: T): number; }
function max<T extends Comparable<T>>(a: T, b: T): T {
  return a.compareTo(b) >= 0 ? a : b;
}

Foutmeldingen voor beperkingen

Wanneer een typeargument niet aan een beperking voldoet, meldt TypeScript een duidelijke fout waarin zowel het argument als de beperking worden genoemd.

Korte controle

Waartoe beperkt `K extends keyof T` K?

Beantwoord dit in de interactieve les

Samenvatting

Gebruik `T extends SomeType` om generieke typeparameters te beperken. Zo kun je specifieke methoden op T aanroepen, keyof gebruiken voor veilige toegang tot eigenschappen en typeveilige hulpfuncties bouwen.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Generieke beperkingen met extends” gratis?

Ja — de volledige tekst van “Generieke beperkingen met extends” 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 “Generieke beperkingen met extends”?

Beperk typeparameters tot specifieke structuren. 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 3 van 4.

Hoe lang duurt de les “Generieke beperkingen met extends”?

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

← Terug naar TypeScript Academy