Vad är generiska begränsningar?

Question

Accepted Answer

En **generisk begränsning** (`T extends ...`) begränsar vilka typer en generisk parameter kan vara, så du kan säkert använda vissa egenskaper eller metoder på den. Utan en begränsning kan en generisk vara *vad som helst*, så du kan inte förutsätta att den har några medlemmar. ```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 är ett *löfte*: "`T` kommer alltid att ha åtminstone denna form," vilket låter kompilatorn tillåta `.length` medan den fortfarande håller `T` precis (returtypen är den faktiska array/string-typen, inte begränsningen). ## Begränsning till nycklar (mycket vanligt) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` garanterar att `key` är en verklig egenskap hos `obj` — och `T[K]` returnerar dess exakta typ. ## Standardtypsparametrar ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Varför det spelar roll Begränsningar är balansen mellan flexibilitet och säkerhet: de låter generisk kod förlita sig på en minimal form (har `.length`, har nyckel `K`, utökar någon bas) medan de bevarar anroparens specifika typ. De är väsentliga för verktygsgenskapsade funktioner, typesäker objektåtkomst och alla generiska som behöver *göra* något med sin typparameter.