Wat zijn generieke constraints?

Question

Accepted Answer

A **generic constraint** (`T extends ...`) beperkt welke typen een generieke parameter kan zijn, zodat je veilig bepaalde eigenschappen of methoden erop kunt gebruiken. Zonder constraint kan een generic *alles* zijn, dus je kunt niet aannemen dat het enige leden heeft. ```ts // ❌ without a constraint, you can't access .length — T might be a number function longestBad(a: T, b: T) { return a.length > b.length ? a : b; // Error: 'length' does not exist on 'T' } // ✅ constrain T to things that HAVE a length function longest(a: T, b: T): T { return a.length > b.length ? a : b; } longest("abc", "de"); // ✅ strings have length longest([1, 2], [3]); // ✅ arrays have length longest(1, 2); // ❌ numbers have no length ``` De constraint is een *belofte*: "`T` zal altijd minstens deze vorm hebben," wat de compiler toestaat `.length` toe te staan terwijl `T` nauwkeurig blijft (het retourtype is het werkelijke array/string-type, niet de constraint). ## Beperking tot sleutels (zeer gebruikelijk) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` garandeert dat `key` een echte eigenschap van `obj` is — en `T[K]` retourneert het exacte type. ## Standaard typeparameters ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Waarom het belangrijk is Constraints zijn de balans tussen flexibiliteit en veiligheid: ze stellen generieke code in staat op een minimale vorm te vertrouwen (heeft `.length`, heeft sleutel `K`, breidt een bepaalde basis uit) terwijl het specifieke type van de oproeper behouden blijft. Ze zijn essentieel voor nutsfuncties, typeveilige objecttoegang en elke generic die iets met zijn typeparameter moet *doen*.