Generic Constraints & Defaults

The plain-language idea

An unconstrained generic function getLength<T>(item: T) can't safely access .length, because T could be anything, including something with no .length at all. A constraint narrows what T is allowed to be:

function getLength<T extends { length: number }>(item: T): number {
  return item.length;   // ✅ safe — every valid T is guaranteed to have .length
}

getLength("hello");        // ✅ strings have .length
getLength([1, 2, 3]);      // ✅ arrays have .length
getLength(42);              // ❌ number has no .length

T extends { length: number } doesn't mean "T is a subtype of that interface" in the class-inheritance sense — it means "T must be at least structurally compatible with that shape," the same structural-typing rule from earlier in this track, now applied to a generic parameter instead of a plain variable.

Constraining one generic parameter by another

function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: "Ada", age: 36 };
getProp(user, "name");   // ✅ typed as string
getProp(user, "email");  // ❌ "email" isn't a key of user

K extends keyof T ties the two generic parameters together: key must be one of T's actual keys — this is exactly the type-safe way to write a generic property-getter, impossible to call with a typo'd key name.

Default type parameters

interface ApiResponse<T = unknown> { data: T; status: number }
const r: ApiResponse = { data: "anything", status: 200 };  // T defaults to unknown

function longest<T>(a: T, b: T) { return a.length > b.length ? a : b; } — error: T might not have .length at all.

BackNext

Watch out

• A constraint restricts what's allowed; it doesn't widen what the generic can express — <T extends { length: number }> still lets T be inferred as the specific, narrow type of whatever was actually passed (e.g. the literal array type), not widened to the constraint itself.
• getProp's K extends keyof T pattern is exactly how libraries type safe deep-object-access helpers — it's one of the most practically useful constraint patterns in real code, not just an academic example.
• A generic default doesn't imply a constraint — <T = unknown> just says "if nothing is specified, use unknown"; you still often want <T extends SomeShape = DefaultShape> combining both when the type genuinely needs restricting too.

Why this matters in interviews

K extends keyof T is one of the most common "prove you actually understand generics" patterns interviewers reach for — implementing a type-safe getProp/pick function from scratch is a great way to demonstrate it.