TypeScript & Advanced Type Systems - Generics, Utility Types & Design Patterns Flashcards

Question 1

Generic Constraints (`extends`)

Accepted Answer

Constrains a generic type parameter to guarantee it implements a specific structure or extends a specific type. Syntax: `function logLength<T extends { length: number }>(arg: T): T`. Passing a type without a `.length` property triggers a compile-time error.

Question 2

`Partial<T>` Utility Type

Accepted Answer

Constructs a type with all properties of `T` set to optional (`?`). Implemented under the hood using a mapped type: `type Partial<T> = { [P in keyof T]?: T[P]; }`.

Question 3

`Required` vs. `Readonly`

Accepted Answer

`Required` removes optional modifiers (`-?`) from all properties of `T`, making them mandatory. `Readonly` prepends the `readonly` modifier to all properties, preventing reassignment after initialization.

Question 4

`Pick<T, K>` Utility Type

Accepted Answer

Constructs a type by extracting a specific subset of property keys `K` from object type `T` (where `K extends keyof T`). Example: `type UserSummary = Pick<User, 'id' | 'email'>;`.

Question 5

`Omit<T, K>` Utility Type

Accepted Answer

Constructs a type by taking all properties from `T` and dropping the specified keys `K`. Equivalent to `Pick>`. Example: `type UserWithoutPassword = Omit;`.

Question 6

`Record<K, T>` Utility Type

Accepted Answer

Constructs an object type whose keys are of type `K` (which must extend `keyof any`, i.e., `string | number | symbol`) and whose property values are of type `T`. Example: `Record<string, User>` maps arbitrary string keys to `User` objects.

Question 7

`Exclude` vs. `Extract`

Accepted Answer

`Exclude` removes types from union `T` that are assignable to `U`. `Extract` selects types from union `T` that are assignable to `U`. Both utilize distributive conditional types.

Question 8

`ReturnType` & `Parameters`

Accepted Answer

`ReturnType` extracts the return type of a function type `T`. `Parameters` extracts a tuple type containing all parameter types of function type `T`. Both use conditional types and the `infer` keyword.

Question 9

Type Narrowing & Built-in Guards

Accepted Answer

The process of refining a broader type (like `string | number` or `unknown`) into a more specific type within a logical block. Common mechanisms: `typeof` (for primitives), `instanceof` (for classes/objects), and the `in` operator (for property checking).

Question 10

User-Defined Type Guards (`is` syntax)

Accepted Answer

Functions whose return type signature uses a type predicate of the form `arg is Type`. When the function evaluates to `true`, TypeScript narrows `arg` to `Type` in that scope.

```typescript
function isString(val: unknown): val is string {
  return typeof val === "string";
}
```

Question 11

Discriminated Unions (Tagged Unions)

Accepted Answer

A pattern combining union types where every constituent member has a shared, literal property (the discriminant/tag). TypeScript automatically narrows the union when checking this tag in `switch` or `if` statements.

Question 12

Exhaustiveness Checking with `never`

Accepted Answer

A compile-time safety check ensuring all variants of a discriminated union are handled in control flow structures. Assigning the default branch to a variable of type `never` produces a TS error if a new union variant is added without updating the code.

Question 13

Conditional Types

Accepted Answer

Types that select one of two branches based on a subtyping relationship test: `T extends U ? X : Y`. If `T` is assignable to `U`, the type resolves to `X`; otherwise, it resolves to `Y`.

Question 14

Distributive Conditional Types

Accepted Answer

When conditional types act on a bare generic type parameter that is a union, they distribute automatically over the union elements: `(A | B) extends U ? X : Y` evaluates to `(A extends U ? X : Y) | (B extends U ? X : Y)`. To prevent distribution, wrap operands in tuples: `[T] extends [U]`.

Question 15

The `infer` Keyword

Accepted Answer

Used within the `extends` clause of a conditional type to introduce a named type variable that is inferred dynamically from a matched structure.

```typescript
type Unpacked<T> = T extends (infer U)[] ? U : T;
```

Question 16

Mapped Types

Accepted Answer

Generic types that iterate over a union of keys (typically via `keyof`) to generate object properties dynamically. Syntax: `{ [K in Keys]: Type }`. Modifiers like `readonly` or `?` can be added (`+`) or removed (`-`).

Question 17

Key Remapping via `as` Clause

Accepted Answer

Allows renaming or filtering property keys during mapped type iteration. Example using template literal types: ```typescript type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K] }; ```

Question 18

Template Literal Types

Accepted Answer

Types built on string template syntax that enable string manipulation and union combinations at the type level. Example: `type Event = `on${'Click' | 'Hover'}`;` expands to `'onClick' | 'onHover'`.

Question 19

Indexed Access Types (`T[K]`)

Accepted Answer

Looks up the type of a specific property or property union on type `T`. Example: `User['id']` returns the type of `id`. `User[keyof User]` produces a union of all value types present in `User`.

Question 20

The `satisfies` Operator

Accepted Answer

Validates that an expression matches a given type constraint without changing or widening the resulting type of the expression. Unlike type assertions (`as T`), `satisfies` preserves the narrowest literal type while performing strict validation.

Question 21

Covariance vs. Contravariance

Accepted Answer

Describes subtype assignability for complex/generic types: **Covariance** preserves subtyping direction ($	ext{Sub} \le 	ext{Super} \implies F[	ext{Sub}] \le F[	ext{Super}]$), seen in object properties and return types. **Contravariance** reverses direction ($	ext{Sub} \le 	ext{Super} \implies F[	ext{Super}] \le F[	ext{Sub}]$), seen in function arguments under `strictFunctionTypes`.

TypeScript & Advanced Type Systems - Generics, Utility Types & Design Patterns

Cards in this deck

Related Flashcard Sets

Neuroscience Fundamentals - Brain Structures & Function

USMLE Step 1 - Physiology & Pathology Essentials

HSK 1 - Essential Chinese Vocabulary & Grammar

Kubernetes Fundamentals - Container Orchestration & Deployment