Generic Constraints & Defaults

A generic constraint, written <T extends Constraint> , restricts a type parameter to types that have a required shape so the function body can use those members safely, while a default type parameter, <T = SomeType> , supplies a fallback type when the caller doesn't provide or imply one.

Learn Generic Constraints & Defaults in our free TypeScript course — an interactive lesson with runnable examples, a practice exercise and a quick reference.

Part of the free TypeScript course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

An unconstrained generic is a job posting that says "anyone may apply". You can't ask applicants to do anything specific because you don't know what they can do. A constraint is a job requirement — "must have a driving licence" ( extends { length: number } ). Now you can confidently ask every applicant to drive (read .length ), and anyone without the licence is rejected at the door (a compile error). A default type is the "if unspecified, we'll assume X" line on the form — a sensible fallback so the common case needs no extra paperwork.

1. <T extends Constraint>

A bare <T> could be anything, so you can't touch any of its properties. Adding extends a shape promises those members exist. The function stays generic — it accepts strings, arrays, or any object with a length — yet the body can safely read .length :

2. Default Parameters & Multiple Constraints

A default type parameter <T = string> is used when the caller neither specifies T explicitly nor gives an argument TypeScript can infer it from. You can also declare several type parameters, each with its own constraint, and combine constraints with defaults:

3. Constraining to keyof — a Safe Getter

The most useful constraint pairs two parameters: <T, K extends keyof T> . The second parameter is forced to be a real key of the first, so a typo becomes a compile error and the return type T[K] is exactly the type of that property:

🎯 Your Turn

Implement the body of a function whose generic is constrained to anything with a length . Fill in the blanks and match the expected output.

Common Errors (and the fix)

• ❌ "Property 'x' does not exist on type 'T'": you accessed a member on an unconstrained generic. ✅ Add a constraint that promises it: <T extends { x: ... }> .
• ❌ Passing a bad key: getProp(user, "naem") → "Argument of type '"naem"' is not assignable to parameter of type 'keyof ...'". ✅ Fix the typo; the keyof constraint caught it for you.
• ❌ Constraint too loose: <T extends object> then doing arithmetic — object doesn't have + . ✅ Constrain to exactly what you use ( { value: number } ).
• ❌ Default never applies: <T = string> seems ignored because an argument let TypeScript infer a different T . ✅ Defaults only kick in when T can't be inferred or specified.
• ❌ Out-of-order parameters: <K extends keyof T, T> errors because K references T before it's declared. ✅ Declare T first: <T, K extends keyof T> .

Pro Tips

• 💡 Constrain to exactly the members you use — no looser, no tighter. It keeps the function maximally reusable yet still safe.
• 💡 Return T , not the constraint , so callers keep their precise types.
• 💡 <T, K extends keyof T> is the workhorse pattern behind type-safe getters, setters, and column selectors — memorise it.
• 💡 Combine constraint + default ( <T extends object = {}> ) when a type must be restricted but also has a sensible no-argument fallback.

Frequently Asked Questions

Mini-Challenge: pluck

Build a type-safe pluck that extracts one property from every object in an array — the runtime form of <T, K extends keyof T> . Follow the outline, run it, and match the example output.

🎉 Lesson Complete

• ✅ <T extends Constraint> limits a type parameter so its members are safe to use
• ✅ Return T to preserve the caller's exact type
• ✅ <T = SomeType> supplies a fallback type when T can't be inferred
• ✅ Declare multiple constrained parameters, e.g. <A extends object, B extends object>
• ✅ <T, K extends keyof T> + return T[K] builds a type-safe getter
• ✅ A parameter can be constrained by another parameter declared before it
• ✅ Next lesson: keyof, typeof & Lookup Types

Practice quiz

Continue this course

• Previous: Conditional Types & infer
• Next: keyof, typeof & Lookup Types