Was sind generische Einschränkungen (Generic Constraints)?

Question

Accepted Answer

Eine **generische Einschränkung** (`T extends ...`) begrenzt die Typen, die ein generischer Parameter sein kann, damit Sie sicher bestimmte Eigenschaften oder Methoden auf ihm verwenden können. Ohne Einschränkung kann ein generischer Typ *alles* sein, daher können Sie nicht davon ausgehen, dass er über irgendwelche Member verfügt. ```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 ``` Die Einschränkung ist ein *Versprechen*: "`T` wird immer mindestens diese Form haben," was dem Compiler erlaubt, `.length` zu akzeptieren und gleichzeitig `T` präzise zu halten (der Rückgabetyp ist der tatsächliche Array-/String-Typ, nicht die Einschränkung). ## Einschränkung auf Schlüssel (sehr häufig) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` garantiert, dass `key` eine echte Eigenschaft von `obj` ist — und `T[K]` gibt seinen genauen Typ zurück. ## Standard-Typparameter ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Warum es wichtig ist Einschränkungen sind der Ausgleich zwischen Flexibilität und Sicherheit: Sie ermöglichen es generischem Code, sich auf eine minimale Form zu verlassen (hat `.length`, hat Schlüssel `K`, erweitert eine Basis) und bewahren gleichzeitig den spezifischen Typ des Aufrufers. Sie sind unverzichtbar für Utility-Funktionen, typsicheren Objektzugriff und jeden generischen Typ, der etwas mit seinem Typparameter *tun* muss.