TypeScript - Advanced Type Systems & Utility Types Flashcards

Question 1

Generics in TypeScript (`<T>`)

Accepted Answer

Reusable type templates that allow functions, classes, or interfaces to work across various types while maintaining strict type safety.

```typescript
function identity<T>(arg: T): T {
  return arg;
}
```

Question 2

Type Alias (`type`) vs. Interface (`interface`)

Accepted Answer

`interface` is optimized for defining object shapes and supports **declaration merging** (adding properties by re-declaring the interface).

`type` is more flexible; it can represent primitives, unions (`|`), intersections (`&`), and tuples, but **cannot** be reopened for declaration merging.

Question 3

Discriminated Unions

Accepted Answer

A pattern that combines union types with a single common literal property (the *discriminant*) to allow TypeScript to narrow down the specific type in `switch` or `if` statements.

```typescript
type Shape =
  | { kind: "square"; size: number }
  | { kind: "circle"; radius: number };
```

Question 4

Utility Type: `Partial<T>`

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 5

Utility Type: `Required<T>`

Accepted Answer

Constructs a type with all properties of `T` set to required by removing optional modifiers using `-?`.

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

Question 6

Utility Type: `Readonly<T>`

Accepted Answer

Constructs a type with all properties of `T` set to `readonly`, preventing property reassignment after initialization.

```typescript
type ImmutableUser = Readonly<{ name: string; age: number }>;
```

Question 7

Utility Type: `Pick<T, K>`

Accepted Answer

Constructs a type by selecting a specific set of keys `K` from object type `T`.

```typescript
type UserPreview = Pick<User, "id" | "name">;
```

Question 8

Utility Type: `Omit<T, K>`

Accepted Answer

Constructs a type with all properties of `T` except those specified in key union `K`.

```typescript
type UserWithoutPassword = Omit<User, "password">;
```

Question 9

Utility Type: `Record<K, T>`

Accepted Answer

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

```typescript
type PageMap = Record<"home" | "about", { title: string }>;
```

Question 10

Conditional Types

Accepted Answer

Types that select one of two branches based on a type relationship test using ternary syntax: `T extends U ? X : Y`.

```typescript
type IsString<T> = T extends string ? true : false;
```

Question 11

The `infer` Keyword

Accepted Answer

Used within the conditional check of a conditional type to introduce a named type variable that is dynamically extracted from another type.

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

Question 12

Mapped Types

Accepted Answer

Generic types that construct new object types by iterating over keys using `in keyof`.

```typescript
type Nullable<T> = {
  [K in keyof T]: T[K] | null;
};
```

Question 13

The `keyof` Operator

Accepted Answer

An indexed type query operator that produces a string or numeric literal union of an object type's property keys.

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

Question 14

Indexed Access Types (`T[K]`)

Accepted Answer

Allows looking up the specific type of a property `K` on type `T`.

```typescript
type Person = { age: number; name: string };
type Age = Person["age"]; // number
```

Question 15

Utility Types: `Exclude` vs `Extract`

Accepted Answer

* `Exclude` removes types from union `T` that are assignable to `U`. * `Extract` extracts types from union `T` that are assignable to `U`. ```typescript type T1 = Exclude<"a" | "b" | "c", "a">; // "b" | "c" type T2 = Extract<"a" | "b" | "c", "a" | "z">; // "a" ```

Question 16

Utility Type: `ReturnType<T>`

Accepted Answer

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

```typescript
type Func = () => string;
type Result = ReturnType<Func>; // string
```

Question 17

Utility Type: `NonNullable<T>`

Accepted Answer

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

```typescript
type Clean = NonNullable<string | null | undefined>; // string
```

Question 18

Template Literal Types

Accepted Answer

Types built using template literal syntax to combine and manipulate string literal types at compile time.

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

Question 19

Distributive Conditional Types

Accepted Answer

When conditional types act on a bare type parameter `T`, they automatically distribute over union types.

For example, if `T` is `A | B`, then `T extends U ? X : Y` evaluates as `(A extends U ? X : Y) | (B extends U ? X : Y)`.

Question 20

Key Remapping in Mapped Types (`as`)

Accepted Answer

Allows renaming keys in mapped types using the `as` clause alongside template literal types. ```typescript type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K] }; ```

TypeScript - Advanced Type Systems & Utility Types

Cards in this deck

Related Flashcard Sets

TypeScript - Advanced Type Systems, Generics & Design Patterns

Harvard ECON1011 - Intermediate Microeconomics: Game Theory & Market Structures

MIT 18.03 - Differential Equations: Ordinary Differential Equations, Laplace & Fourier

CPA Exam FAR - Financial Accounting & Reporting: US GAAP & Revenue Recognition