Advanced Types & Utilities

Question 1

What is a mapped type in TypeScript?

Answer 1

A mapped type creates new types by transforming properties of an existing type using constructs like in and keyof.

Question 2

What is a conditional type in TypeScript?

Answer 2

A conditional type uses a ternary expression to choose between types based on a condition, like T extends U ? X : Y.

Question 3

What does the utility type Partial<T> do?</T>

Answer 3

Partial<T> makes all properties of type T optional.

Question 4

What does the utility type Required<T> do?</T>

Answer 4

Required<T> makes all properties of type T required.

Question 5

What does the utility type Readonly<T> do?</T>

Answer 5

Readonly<T> makes all properties of type T read-only.

Question 6

What does the utility type Pick<T, K> do?

Answer 6

Pick<T, K> creates a new type by selecting a subset K of properties from type T.

Question 7

What does the utility type Omit<T, K> do?

Answer 7

Omit<T, K> creates a new type by excluding properties K from type T.

Question 8

What does the utility type Record<K, T> do?

Answer 8

Record<K, T> creates a type with keys K and values of type T.

Question 9

What does ‘keyof’ return in TypeScript?

Answer 9

keyof returns a union of property names (as strings) of a given type.

Question 10

What does ‘typeof’ return in TypeScript?

Answer 10

typeof returns the type of a variable, used to infer its type in type declarations.

Question 11

What does ‘infer’ do in TypeScript?

Answer 11

infer is used within conditional types to infer a type inside a condition and reuse it.

Question 12

What does ‘in’ do in TypeScript types?

Answer 12

in is used in mapped types to iterate over keys in a union or another type.

Question 13

What is an advantage of using mapped types?

Answer 13

They enable creation of flexible, reusable, and type-safe modifications of existing types.

Question 14

What is a disadvantage of conditional types?

Answer 14

They can become complex and hard to read, especially when deeply nested or combined with infer.

Question 15

What is a use case for Partial<T>?</T>

Answer 15

When updating a subset of properties in a form or data structure.

Question 16

What is a use case for Readonly<T>?</T>

Answer 16

When you want to protect data from being modified after creation.

Question 17

What is a use case for Pick<T, K>?

Answer 17

When selecting specific fields from a larger interface for a component or function.

Question 18

What is a use case for Omit<T, K>?

Answer 18

When removing sensitive or irrelevant fields before exposing an object.

Question 19

What is a use case for Record<K, T>?

Answer 19

When you want to create an object type with known keys and uniform value types.

Question 20

What’s a best practice for using Partial<T>?</T>

Answer 20

Only use Partial<T> when fields are truly optional—otherwise use default values.

Question 21

What’s a best practice for using Omit<T, K>?

Answer 21

Prefer it when you need to hide or exclude certain properties from the exposed types.

Question 22

What is a potential gotcha with infer?

Answer 22

infer only works inside conditional types and can lead to obscure code if overused.

Question 23

What’s a real-world tradeoff with mapped types?

Answer 23

They reduce duplication but can introduce complexity when debugging nested generics.

Question 24

What’s a debugging tip for conditional types?

Answer 24

Break them into smaller, testable components and check inferred types using IDEs or type playgrounds.

Question 25

How do utility types affect performance?

Answer 25

No runtime impact—utility types are compile-time constructs only.

Question 26

What’s a monitoring implication of mapped types?

Answer 26

They can complicate stack traces when types are deeply abstracted, making error mapping harder.

Question 27

How do these advanced types affect architecture?

Answer 27

They enable creation of strongly typed APIs and flexible data layers with reusable contracts.

Question 28

What’s an example of using keyof with a function?

Answer 28

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

Question 29

What’s an interview question about Pick vs Omit?

Answer 29

When would you choose `Pick` over `Omit` and vice versa?

Question 30

What’s a performance implication of Record?

Answer 30

It has no runtime overhead, but too wide a type like `any` may allow unsafe operations.

Question 31

What’s a benefit of using Readonly in APIs?

Answer 31

It enforces immutability, reducing side effects and increasing predictability.

Question 32

What’s a disadvantage of overusing mapped types?

Answer 32

It can lead to deeply nested types that are hard to interpret and debug.

Question 33

What’s a good use of infer with ReturnType?

Answer 33

To extract the return type of a function using `ReturnType`.

Question 34

What’s a gotcha with Pick?

Answer 34

If K contains an invalid key, TypeScript throws an error—requires accurate key unions.

Question 35

What’s a real-world use of Record?

Answer 35

Creating a dictionary-like object: `Record<'low' | 'medium' | 'high', number>` for priorities.

Question 36

What is a debugging strategy for utility types?

Answer 36

Simplify complex types by checking intermediate results with helper interfaces.

Question 37

What’s an architectural implication of utility types?

Answer 37

They reduce duplication and allow consistent modeling across service boundaries.

Question 38

Can you nest utility types?

Answer 38

Yes, e.g., `Readonly>` is valid and creates a deeply immutable optional type.

Question 39

What is an anti-pattern with utility types?

Answer 39

Creating overly abstract types that obscure the original business logic.

Question 40

What’s the difference between Pick and Omit?

Answer 40

`Pick` selects properties, `Omit` excludes them—use depending on whether you're whitelisting or blacklisting.

Question 41

What’s a good best practice for keyof?

Answer 41

Use it to enforce strict access to object properties via safe accessors.

Question 42

How do you restrict inferred types with infer?

Answer 42

Use it in a constraint like `T extends (x: infer U) => any ? U : never`.

Question 43

Why is Record useful in configuration objects?

Answer 43

It lets you map known keys to typed values in a safe, repeatable way.

Question 44

What’s the impact of these types on system design?

Answer 44

They enable safer, scalable codebases by minimizing human errors in type definitions.

Question 45

Why prefer utility types over manual typing?

Answer 45

They reduce redundancy, ensure consistency, and leverage TypeScript’s static analysis.

Question 46

How does 'in' differ in mapped types vs JavaScript?

Answer 46

In mapped types, `in` is used to iterate over keys; in JS, it's used to check key existence.

Question 47

What’s a potential gotcha with typeof?

Answer 47

`typeof` in types only works on values—not type aliases or interfaces.

Question 48

What’s a challenge with conditional types and union types?

Answer 48

Distributive behavior over union types can lead to unexpected results if not handled carefully.