TypeScript - Advanced Types & Interfaces Flashcards

Question 1

Interface vs. Type: Declaration Merging

Accepted Answer

An `interface` can be declared multiple times with the same name, and TypeScript will automatically merge their definitions together. A `type` alias cannot be redeclared once defined; attempting to do so will trigger a compile-time error.

Question 2

Interface vs. Type: Syntax & Extensibility

Accepted Answer

`interface` extends other structures using the `extends` keyword (e.g., `interface B extends A {}`). A `type` alias extends other types using intersection operators (e.g., `type B = A & { ... }`). Unlike interfaces, type aliases can also directly represent primitives, unions, and tuples.

Question 3

Utility Type: `Partial<T>`

Accepted Answer

`Partial` constructs a type with all properties of `T` set to optional. Under the hood: ```typescript type Partial = { [P in keyof T]?: T[P]; }; ```

Question 4

Utility Type: `Required<T>`

Accepted Answer

`Required` constructs a type with all properties of `T` set to required. It explicitly removes the optional modifier using `-?`. Under the hood: ```typescript type Required = { [P in keyof T]-?: T[P]; }; ```

Question 5

Utility Type: `Readonly<T>`

Accepted Answer

`Readonly` constructs a type with all properties of `T` set to `readonly`. Reassigning properties of an object typed with `Readonly` will cause a compile-time error.

Question 6

Utility Type: `Pick<T, K>`

Accepted Answer

`Pick` constructs a type by selecting a specified set of keys `K` from object type `T`. Example: ```typescript interface User { id: number; name: string; email: string; } type UserSummary = Pick; ```

Question 7

Utility Type: `Omit<T, K>`

Accepted Answer

`Omit` constructs a type with all properties of `T` except those listed in `K`. Example: ```typescript interface User { id: number; name: string; passwordHash: string; } type PublicUser = Omit; ```

Question 8

Utility Type: `Record<K, T>`

Accepted Answer

`Record` constructs an object type whose property keys are `K` and whose property values are `T`. It maps a set of string or numeric literal keys to another type. Example: ```typescript type Role = 'admin' | 'user'; type Permissions = Record; ```

Question 9

Conditional Types Syntax

Accepted Answer

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

Syntax:
`T extends U ? X : Y`

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

Question 10

Distributive Conditional Types

Accepted Answer

When conditional types act on a generic type parameter that is a union, they automatically distribute over the union members.

Example:
If `T` is `A | B`, then `T extends U ? X : Y` expands to:
`(A extends U ? X : Y) | (B extends U ? X : Y)`

Question 11

Preventing Conditional Type Distribution

Accepted Answer

To prevent a conditional type from distributing over union types, wrap both sides of the `extends` keyword in square brackets `[]`.

Example:
```typescript
type NonDistributive<T> = [T] extends [string] ? true : false;
```

Question 12

Mapped Types

Accepted Answer

A mapped type constructs a new object type by iterating over property keys using the `in` operator.

Syntax:
```typescript
type Flags<T> = {
  [K in keyof T]: boolean;
};
```

Question 13

Key Remapping via `as` in Mapped Types

Accepted Answer

Key remapping allows you to transform or filter keys in a mapped type using the `as` clause. Example: ```typescript type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K]; }; ```

Question 14

Discriminated Unions

Accepted Answer

A pattern for safe type handling of variant objects. It requires three components:
1. Types with a common, literal property (the *discriminant*).
2. A union type alias combining those types.
3. Type guard checks (e.g., `switch` or `if`) on the discriminant.

Question 15

Declaration Merging Practice

Accepted Answer

Declaration merging allows developers to extend existing types from third-party libraries or global namespaces.

Example:
```typescript
declare global {
  interface Window {
    customProperty: string;
  }
}
```

Question 16

The `infer` Keyword

Accepted Answer

The `infer` keyword introduces a temporary type variable inside the conditional check of a conditional type to deduce types automatically.

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

Question 17

The `keyof` Type Operator

Accepted Answer

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

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

Question 18

Indexed Access Types

Accepted Answer

Indexed access types (or lookup types) look up the specific type of a property on another type using bracket notation.

Example:
```typescript
type User = { id: number; name: string };
type UserId = User['id']; // number
```

Question 19

Template Literal Types

Accepted Answer

Template literal types build upon string literal types and can expand into combinations of string literal types.

Example:
```typescript
type Element = 'button' | 'input';
type Event = `on${Capitalize<Element>}`;
// Result: 'onButton' | 'onInput'
```

Question 20

The `satisfies` Operator

Accepted Answer

The `satisfies` operator validates that an expression matches a target type without widening or altering the inferred type of the expression.

Example:
```typescript
const config = {
  host: 'localhost',
  port: 8080
} satisfies Record<string, string | number>;

// config.host is inferred as string, not string | number
```

Question 21

`Exclude` vs. `Extract`

Accepted Answer

`Exclude` constructs a type by removing from `T` all union members assignable to `U`. `Extract` constructs a type by extracting from `T` all union members assignable to `U`. Example: ```typescript type T0 = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c' type T1 = Extract<'a' | 'b' | 'c', 'a' | 'z'>; // 'a' ```

TypeScript - Advanced Types & Interfaces

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