Hvad er generiske begrænsninger?

Question

Accepted Answer

En **generisk begrænsning** (`T extends ...`) begrænser, hvilke typer en generisk parameter kan være, så du kan sikkert bruge bestemte egenskaber eller metoder på den. Uden en begrænsning kan en generisk være *hvad som helst*, så du kan ikke antage, at den har nogle medlemmer. ```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 ``` Begrænsningen er et *løfte*: "`T` vil altid have mindst denne form," hvilket lader compileren tillade `.length` samtidig med at holde `T` præcis (returtypen er den faktiske array/string-type, ikke begrænsningen). ## Begrænsning til nøgler (meget almindeligt) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` garanterer, at `key` er en rigtig egenskab på `obj` — og `T[K]` returnerer dens nøjagtige type. ## Standardtypeparametre ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Hvorfor det betyder noget Begrænsninger er balancen mellem fleksibilitet og sikkerhed: de lader generisk kode stole på en minimal form (har `.length`, har nøgle `K`, udvider en vis base) samtidig med at bevare den specifikke type hos opkalderen. De er vigtige for utility-funktioner, type-sikker objektadgang og enhver generik, der skal *gøre* noget med dens typeparameter.