What are generic constraints?

Question

Accepted Answer

A **generic constraint** (`T extends ...`) restricts what types a generic parameter can be, so you can safely use certain properties or methods on it. Without a constraint, a generic could be *anything*, so you can't assume it has any members. ```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 ``` The constraint is a *promise*: "`T` will always have at least this shape," which lets the compiler allow `.length` while still keeping `T` precise (the return type is the actual array/string type, not the constraint). ## Constraining to keys (very common) ```ts function pluck(obj: T, key: K): T[K] { return obj[key]; } ``` `K extends keyof T` guarantees `key` is a real property of `obj` — and `T[K]` returns its exact type. ## Default type parameters ```ts interface Box { value: T; } // T defaults to string if not specified ``` ## Why it matters Constraints are the balance between flexibility and safety: they let generic code rely on a minimal shape (has `.length`, has key `K`, extends some base) while preserving the caller's specific type. They're essential for utility functions, type-safe object access, and any generic that needs to *do* something with its type parameter.