TypeScript - Advanced Type Systems, Generics & Utility Types Flashcards

Question 1

How does `unknown` differ from `any` in TypeScript?

Accepted Answer

`any` disables all type-checking, allowing arbitrary property access and operations without safety. `unknown` is the type-safe counterpart; it represents any value, but TypeScript prevents operations on an `unknown` variable until it is narrowed through type guards or type assertion.

Question 2

What is the `never` type and when is it used?

Accepted Answer

The `never` type represents the type of values that never occur. It is used for functions that never return (e.g., throw errors or infinite loops) and to enforce exhaustiveness checking in conditional branches or discriminated unions.

Question 3

How do `typeof` and `instanceof` narrow types in TypeScript?

Accepted Answer

- `typeof`: Narrows primitive types at runtime (e.g., `typeof x === 'string'`). Valid return strings are `'string'`, `'number'`, `'bigint'`, `'boolean'`, `'symbol'`, `'undefined'`, `'object'`, and `'function'`.
- `instanceof`: Narrows object types by checking if an object's prototype chain contains a constructor function (e.g., `err instanceof Error`).

Question 4

What is a User-Defined Type Guard (Type Predicate)?

Accepted Answer

A function that performs a runtime check and returns a boolean, with a special return type signature `arg is Type` that informs the compiler to narrow `arg` within conditional blocks.

```typescript
function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}
```

Question 5

How does the `in` operator perform type narrowing?

Accepted Answer

The `in` operator checks if a property exists on an object type, narrowing union types based on property presence.

```typescript
type Admin = { name: string; privileges: string[] };
type User = { name: string };

function checkRole(account: Admin | User) {
  if ('privileges' in account) {
    // account is narrowed to Admin
  }
}
```

Question 6

What is a Discriminated Union (Tagged Union)?

Accepted Answer

A pattern where multiple object types share a common literal property (the 'discriminant'), allowing TypeScript to automatically narrow down the specific type based on checks against that property.

```typescript
type Circle = { kind: 'circle'; radius: number };
type Square = { kind: 'square'; sideLength: number };
type Shape = Circle | Square;
```

Question 7

How is the `never` type used for exhaustiveness checking?

Accepted Answer

By assigning an unhandled branch in a `switch` or `if` statement to a variable of type `never`, TypeScript will raise a compile-time error if a new union member is added but not handled.

```typescript
function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle': return Math.PI * shape.radius ** 2;
    case 'square': return shape.sideLength ** 2;
    default:
      const _exhaustiveCheck: never = shape; // Compiler error if new shape added
      return _exhaustiveCheck;
  }
}
```

Question 8

What is a Generic Constraint and how is it declared?

Accepted Answer

A generic constraint restricts the types that can be passed to a generic type parameter using the `extends` keyword.

```typescript
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length;
}
```

Question 9

What does the `keyof` operator do?

Accepted Answer

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

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

Question 10

What is the Indexed Access Type syntax in TypeScript?

Accepted Answer

Indexed Access Types look up specific properties on another type using `Type[Key]`.

```typescript
type User = { id: number; name: string; address: { city: string } };
type Address = User['address']; // { city: string }
type UserProperty = User['id' | 'name']; // number | string
```

Question 11

How do `Partial` and `Required` utility types work?

Accepted Answer

- `Partial` constructs a type with all properties of `T` set to optional (`?`). - `Required` constructs a type with all properties of `T` set to required, removing optionality (`-?`).

Question 12

What is `Readonly<T>` and does it provide deep immutability?

Accepted Answer

`Readonly<T>` makes all root-level properties of a type `readonly`, preventing reassignment. It is **shallow**, meaning nested objects remain mutable unless wrapped in custom deep readonly types.

Question 13

How does `Record<K, T>` work?

Accepted Answer

`Record` constructs an object type whose property keys are of type `K` and whose property values are of type `T`. ```typescript type Page = 'home' | 'about' | 'contact'; type PageMeta = Record; ```

Question 14

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

Accepted Answer

- `Pick` constructs a type by selecting specified keys `K` from `T`. - `Omit` constructs a type by picking all properties from `T` and then removing keys `K`.

Question 15

What do `Exclude` and `Extract` do on union types?

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 T0 = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c' type T1 = Extract<'a' | 'b' | 'c', 'a' | 'f'>; // 'a' ```

Question 16

How does `ReturnType<T>` extract function return types?

Accepted Answer

`ReturnType` constructs a type consisting of the return type of function type `T` using the `typeof` operator when pointing to actual function implementations. ```typescript function createObj() { return { id: 1, name: 'Item' }; } type Obj = ReturnType; // { id: number; name: string } ```

Question 17

What are Mapped Types in TypeScript?

Accepted Answer

Mapped types allow you to create new types based on existing ones by iterating over key signatures using `[K in keyof T]` syntax.

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

Question 18

What is a Conditional Type and what is its syntax?

Accepted Answer

Conditional types select one of two types based on a condition expressed as a type relationship test using `extends`.

`T extends U ? X : Y`

If `T` is assignable to `U`, the type becomes `X`, otherwise `Y`.

Question 19

How does the `infer` keyword work in conditional types?

Accepted Answer

The `infer` keyword declares a temporary type variable within the extends clause of a conditional type to be automatically inferred by TypeScript. ```typescript type UnpackArray = T extends (infer U)[] ? U : T; type Num = UnpackArray; // number ```

Question 20

What are Template Literal Types and how are they used?

Accepted Answer

Template Literal Types build upon string literal types to produce new string literal types via template literal syntax, generating combinations when combined with unions.

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

TypeScript - Advanced Type Systems, Generics & 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