TypeScript Mapped Types — Complete Interview Guide

Basic Mapped Type Syntax

// The fundamental pattern: [P in keyof T]: SomeType
// P is each key of T in turn, like a for..in loop over type keys

type Stringify<T> = {
  [P in keyof T]: string; // every property becomes a string
};

interface User { id: number; name: string; active: boolean; }
type StringifiedUser = Stringify<User>;
// { id: string; name: string; active: string; }

// Preserve the original value type using T[P] (indexed access)
type Identity<T> = {
  [P in keyof T]: T[P]; // copies the type exactly
};
// Identity<User> === User (structurally)

Adding and Removing Modifiers

Mapped types can add or remove the readonly and ? (optional) modifiers using + (add) and - (remove) prefixes:

// Adding modifiers — + is implicit (same as no prefix)
type MyReadonly<T> = {
  +readonly [P in keyof T]: T[P]; // add readonly to every property
};
type MyPartial<T> = {
  [P in keyof T]+?: T[P]; // add ? to every property
};

// Removing modifiers — the - prefix
type MyRequired<T> = {
  [P in keyof T]-?: T[P]; // -? removes the optional modifier
};
type MyMutable<T> = {
  -readonly [P in keyof T]: T[P]; // -readonly removes readonly
};

// Combining: make every property required AND mutable
type Concrete<T> = {
  -readonly [P in keyof T]-?: T[P];
};

Key Remapping with as

TypeScript 4.1+ allows renaming keys in mapped types using an as clause — enabling prefix addition, case transformation, and key filtering:

// Add a 'get' prefix to every key
type Getters<T> = {
  [P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
};

interface User { name: string; email: string; id: number; }
type UserGetters = Getters<User>;
// { getName: () => string; getEmail: () => string; getId: () => number; }

// Filter keys using never — never keys are omitted from the output
type OnlyStrings<T> = {
  [P in keyof T as T[P] extends string ? P : never]: T[P];
};
type UserStringFields = OnlyStrings<User>;
// { name: string; email: string; } — id (number) is filtered out

// Map to event handler keys
type EventHandlers<T> = {
  [P in keyof T as `on${Capitalize<string & P>}`]: (value: T[P]) => void;
};

Implementing Built-in Utility Types

Every built-in utility type is a mapped type. Understanding their implementations is the mark of a senior TypeScript developer:

// Partial — adds ?
type Partial<T> = { [P in keyof T]?: T[P]; };

// Required — removes ?
type Required<T> = { [P in keyof T]-?: T[P]; };

// Readonly — adds readonly
type Readonly<T> = { readonly [P in keyof T]: T[P]; };

// Pick — only iterates over the specified keys K
type Pick<T, K extends keyof T> = { [P in K]: T[P]; };

// Record — K is any union of keys, V is the value type
type Record<K extends keyof any, V> = { [P in K]: V; };

// These are all in TypeScript's own lib.es5.d.ts — reading the source is instructive

Mapped Types with Conditional Types

Combining mapped types with conditional types enables powerful type transformations:

// Deep Partial — recursively makes all nested properties optional
type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

// Make only specific properties optional
type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface User { id: number; name: string; email: string; }
type UserCreate = PartialBy<User, "id">;
// { id?: number; name: string; email: string; } — id optional, rest required

// Extract function-valued properties
type FunctionProperties<T> = {
  [P in keyof T as T[P] extends Function ? P : never]: T[P];
};

// Flatten a nested type by one level
type Flatten<T> = {
  [P in keyof T]: T[P] extends Array<infer U> ? U : T[P];
};

Distributive Mapped Types over Unions

// When T is a union, the mapped type applies to each member separately
type NullableFields<T> = { [P in keyof T]: T[P] | null };

// Works correctly over unions via distributive keyof behaviour
type Config = { host: string; port: number };
type NullableConfig = NullableFields<Config>;
// { host: string | null; port: number | null; }