TypeScript - Advanced Types, Generics & Utility Types Flashcards

Question 1

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

Accepted Answer

`Partial` constructs a type with all properties of `T` set to optional (`?`). ```ts type Partial = { [P in keyof T]?: T[P]; }; ```

Question 2

What is the `keyof` operator in TypeScript?

Accepted Answer

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

```ts
type Point = { x: number; y: number };
type PointKeys = keyof Point; // 'x' | 'y'
```

Question 3

What are Mapped Types in TypeScript?

Accepted Answer

Mapped types allow you to create new types by iterating over property keys of an existing type using the `in` keyword.

```ts
type ReadonlyFlags<T> = {
  readonly [K in keyof T]: boolean;
};
```

Question 4

How do Conditional Types work in TypeScript?

Accepted Answer

Conditional types select one of two possible types based on a condition expressed as 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 5

What is the `infer` keyword used for in Conditional Types?

Accepted Answer

The `infer` keyword allows you to declare and extract a type variable within the `extends` clause of a conditional type. ```ts type ElementType = T extends (infer U)[] ? U : T; type Num = ElementType; // number ```

Question 6

What are Template Literal Types?

Accepted Answer

Template literal types build on string literal types and expand into union types when interpolated with other literal unions.

```ts
type Event = 'click' | 'hover';
type EventHandler = `on${Capitalize<Event>}`;
// 'onClick' | 'onHover'
```

Question 7

What is a Discriminated Union?

Accepted Answer

A pattern where multiple object types share a common single-literal property (the 'discriminant'), allowing TypeScript to narrow down the specific type in a union using a `switch` or `if` statement.

```ts
type Shape = 
  | { kind: 'square'; size: number }
  | { kind: 'circle'; radius: number };
```

Question 8

How does the `in` operator narrow types?

Accepted Answer

The `in` operator checks if a property name exists on an object, serving as a type guard to narrow down union types.

```ts
if ('radius' in shape) {
  console.log(shape.radius);
}
```

Question 9

What is a User-Defined Type Guard?

Accepted Answer

A function whose return type annotation is a type predicate of the form `arg is Type`. When it returns `true`, TypeScript narrows the argument's type in that scope.

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

Question 10

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

Accepted Answer

`Required` constructs a type with all properties of `T` set to required by removing the optional modifier (`-?`). ```ts type Required = { [P in keyof T]-?: T[P]; }; ```

Question 11

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

Accepted Answer

`Record` constructs an object type whose property keys are `K` and whose property values are `T`. ```ts type PageInfo = { title: string }; type Page = 'home' | 'about'; type Pages = Record; ```

Question 12

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

Accepted Answer

`Pick` constructs a type by picking the set of properties `K` (union of key literals) from `T`. ```ts type User = { id: string; name: string; age: number }; type UserPreview = Pick; ```

Question 13

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

Accepted Answer

`Omit` constructs a type by picking all properties from `T` and then removing keys `K`. ```ts type User = { id: string; name: string; passwordHash: string }; type PublicUser = Omit; ```

Question 14

What does the `ReturnType<T>` utility type do?

Accepted Answer

`ReturnType` extracts the return type of a function type `T` using the `infer` keyword internally. ```ts type Func = () => number; type Num = ReturnType; // number ```

Question 15

What does the `Parameters<T>` utility type do?

Accepted Answer

`Parameters` extracts a tuple type of the parameter types of a function type `T`. ```ts type Func = (a: string, b: number) => void; type Params = Parameters; // [a: string, b: number] ```

Question 16

What is Key Remapping in Mapped Types?

Accepted Answer

Key remapping allows you to re-index or filter property keys in mapped types using an `as` clause and template literals. ```ts type Getters = { [K in keyof T as `get${Capitalize}`]: () => T[K] }; ```

Question 17

What is Exhaustiveness Checking in TypeScript?

Accepted Answer

A compile-time technique using the `never` type to ensure all cases in a discriminated union are handled in a conditional or `switch` block.

```ts
default:
  const _exhaustiveCheck: never = shape;
  return _exhaustiveCheck;
```

Question 18

What is the difference between `Omit` and `Exclude`?

Accepted Answer

- `Omit` operates on **object types** to remove specific keys `K`. - `Exclude` operates on **union types** to exclude members `U` from generic union `T`. Under the hood, `Omit` uses `Exclude`: `Pick>`.

Question 19

What is a Distributive Conditional Type?

Accepted Answer

When conditional types act on a generic type parameter that is a naked union type, they automatically distribute over the union's members. ```ts type ToArray = T extends any ? T[] : never; type Result = ToArray; // string[] | number[] ```

Question 20

What is the `NonNullable<T>` utility type?

Accepted Answer

`NonNullable` constructs a type by excluding `null` and `undefined` from `T`. ```ts type NonNullable = T extends null | undefined ? never : T; type T0 = NonNullable; // string ```

TypeScript - Advanced Types, Generics & Utility Types

Cards in this deck

Related Flashcard Sets

TypeScript - Advanced Types & Tooling

TypeScript Masterclass - Advanced Types, Generics & Type Manipulation

TypeScript - Advanced Type Systems & Utility Types

TypeScript - Advanced Type Systems, Generics & Utility Types