TypeScript Masterclass - Advanced Types, Generics & Type Manipulation Flashcards

Question 1

Union Types vs. Intersection Types

Accepted Answer

A **Union Type** (`A | B`) describes a value that can be *either* type `A` or type `B`. An **Intersection Type** (`A & B`) combines multiple types into one, producing a type that possesses all properties of both `A` and `B` simultaneously.

Question 2

Generic Constraints (`extends`) Limit Generic Parameters

Accepted Answer

Generic constraints restrict the types that can be passed to a generic parameter using the `extends` keyword.

Example:
```typescript
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length;
}
```
Here, `T` must be an object type containing at least a numeric `length` property.

Question 3

The `keyof` Type Operator

Accepted Answer

The `keyof` operator takes an object type and produces a string or numeric literal union of its keys.

Example:
```typescript
type User = { id: number; name: string };
type UserKeys = keyof User; // 'id' | 'name'
```

Question 4

Indexed Access Types (`T[K]`) Look Up Property Types

Accepted Answer

Indexed access types look up the specific type of a property on another type using key indexing.

Example:
```typescript
type User = { id: number; name: string; active: boolean };
type NameType = User['name']; // string
type KeyTypes = User['id' | 'active']; // number | boolean
```

Question 5

Conditional Types Syntax and Evaluation

Accepted Answer

Conditional types select one of two possible types based on a subtyping relationship test.

Syntax:
`T extends U ? X : Y`

If type `T` is assignable to type `U`, the result is type `X`; otherwise, it evaluates to type `Y`.

Question 6

The `infer` Keyword in Conditional Types

Accepted Answer

The `infer` keyword declares a type variable within the `extends` clause of a conditional type to extract and infer a subtype. Example: ```typescript type UnpackArray = T extends (infer U)[] ? U : T; type Num = UnpackArray; // number ```

Question 7

Distributive Conditional Types

Accepted Answer

When conditional types act on a generic type parameter that is a union, they automatically distribute over each constituent of that union. Example: ```typescript type ToArray = T extends any ? T[] : never; type Result = ToArray; // string[] | number[] ```

Question 8

Preventing Distribution in Conditional Types

Accepted Answer

To prevent conditional types from distributing over unions, wrap both sides of the `extends` clause in square brackets `[ ]`. Example: ```typescript type NonDistributive = [T] extends [any] ? T[] : never; type Result = NonDistributive; // (string | number)[] ```

Question 9

Mapped Types

Accepted Answer

Mapped types build new object types by iterating over key signatures using the `in` operator.

Syntax:
```typescript
type OptionsFlags<T> = {
  [K in keyof T]: boolean;
};
```
This transforms every property value type in `T` into a `boolean`.

Question 10

Mapping Modifiers (`+` and `-`) in Mapped Types

Accepted Answer

Mapping modifiers add (`+`) or remove (`-`) attributes like `readonly` or optionality (`?`). If omitted, `+` is assumed.

Example:
```typescript
type Concrete<T> = {
  -readonly [P in keyof T]-?: T[P];
};
```
This removes both `readonly` and optional `?` flags from all properties.

Question 11

Key Remapping via `as` in Mapped Types

Accepted Answer

You can rename keys in a mapped type using an `as` clause alongside template literal types or key filtering. Example: ```typescript type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K]; }; ```

Question 12

Template Literal Types

Accepted Answer

Template literal types build string literal types using template literal syntax, producing all possible union combinations when combined with string unions.

Example:
```typescript
type Event = "click" | "hover";
type Handler = `on${Capitalize<Event>}`; // "onClick" | "onHover"
```

Question 13

`Partial<T>` Built-in Utility Type

Accepted Answer

Constructs a type with all properties of `T` set to optional (`?`).

Implementation:
```typescript
type Partial<T> = {
  [P in keyof T]?: T[P];
};
```

Question 14

`Required<T>` Built-in Utility Type

Accepted Answer

Constructs a type with all properties of `T` marked as required by removing optionality (`-?`).

Implementation:
```typescript
type Required<T> = {
  [P in keyof T]-?: T[P];
};
```

Question 15

`Readonly<T>` Built-in Utility Type

Accepted Answer

Constructs a type where all properties of `T` are marked as `readonly`, preventing property reassignment.

Implementation:
```typescript
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};
```

Question 16

`Record<K, T>` Built-in Utility Type

Accepted Answer

Constructs an object type whose property keys are of type `K` and property values are of type `T`.

Implementation:
```typescript
type Record<K extends keyof any, T> = {
  [P in K]: T;
};
```

Question 17

`Pick<T, K>` Built-in Utility Type

Accepted Answer

Constructs a type by picking the set of properties `K` (string literal or union of literals) from type `T`.

Implementation:
```typescript
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};
```

Question 18

`Omit<T, K>` Built-in Utility Type

Accepted Answer

Constructs a type by taking all properties from `T` and then removing keys specified in `K`. Implementation: ```typescript type Omit = Pick>; ```

Question 19

`Exclude` vs. `Extract` Utility Types

Accepted Answer

* `Exclude` removes assignable types `U` from union `T` (`T extends U ? never : T`). * `Extract` extracts assignable types `U` from union `T` (`T extends U ? T : never`).

Question 20

`ReturnType<T>` Utility Type

Accepted Answer

Extracts the return type of a function type `T` using conditional types and `infer`.

Implementation:
```typescript
type ReturnType<T extends (...args: any) => any> =
  T extends (...args: any) => infer R ? R : any;
```

Question 21

`NonNullable<T>` Utility Type

Accepted Answer

Constructs a type by excluding `null` and `undefined` from the type union `T`.

Implementation:
```typescript
type NonNullable<T> = T extends null | undefined ? never : T;
```

TypeScript Masterclass - Advanced Types, Generics & Type Manipulation

Cards in this deck

Related Flashcard Sets

JLPT N2 - Upper-Intermediate Japanese Kanji, Grammar & Expressions

CompTIA Network+ (N10-008) - Networking Fundamentals & Subnetting

HSK 4 - Intermediate Chinese Vocabulary & Grammar

CompTIA Network+ (N10-008) - Networking Fundamentals & Protocols