Generic constraints with extends in Typescript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the extends keyword do in TypeScript generics?

It limits the types that a generic can accept by requiring the type to be a subtype of the specified type or interface.

beginner

How do you write a generic function that only accepts objects with a name property of type string?

Use a generic constraint like <T extends { name: string }> to ensure the type has a name property of type string.

intermediate

Why use generic constraints with extends instead of just using a specific type?

Generic constraints allow flexibility by accepting any type that meets the condition, making code reusable while still ensuring type safety.

beginner

What happens if you try to use a type that does not satisfy the extends constraint?

TypeScript will show a compile-time error because the type does not meet the required structure or properties.

beginner

Example: What does this function signature mean?<br>function logName<T extends { name: string }>(obj: T): void

It means the function logName accepts an object obj of any type T as long as T has a name property of type string.

What does T extends U mean in TypeScript generics?

A T can be any type

B T must be a subtype of U

C U must be a subtype of T

D T and U must be the same type

T extends U means T must be a subtype or satisfy the structure of U.

Which of these is a valid generic constraint to require a length property?

A <code>&lt;T extends boolean&gt;</code>

B <code>&lt;T extends number&gt;</code>

C <code>&lt;T extends { length: number }&gt;</code>

D <code>&lt;T extends string&gt;</code>

Only <T extends { length: number }> ensures the type has a length property.

What error occurs if you pass a number to function f<T extends { name: string }>(obj: T)?

A Type 'number' is not assignable to type '{ name: string }'

B Runtime error

C No error

D Syntax error

TypeScript shows a compile-time error because number does not have a name property.

Why use generic constraints instead of concrete types?

A To allow more flexible and reusable code

B To make code slower

C To avoid type checking

D To restrict code to one type only

Generic constraints allow flexibility while keeping type safety.

Which of these is a correct way to declare a generic function with a constraint?

A function example&lt;T&gt;(arg: T extends { id: number }): void {}

B function example&lt;T&gt;(arg: T): T extends { id: number }

C function example(arg: T extends { id: number }): void {}

D function example&lt;T extends { id: number }&gt;(arg: T): void {}

Option D correctly uses extends in the generic parameter list.

Explain how generic constraints with extends help in writing safer TypeScript code.

Think about how you tell TypeScript what kind of types are allowed.

Write a simple generic function using extends to accept only objects with a length property.

Use <code>&lt;T extends { length: number }&gt;</code> and access <code>obj.length</code>.