TypeScript Mapped Types

Mapped types

Common ones:

Record

Example

type PartialPerson = { [P in keyof Person]?: Person[P] };
type ReadonlyPerson = { readonly [P in keyof Person]: Person[P] };

Basic Mapped Type Syntax

Core Syntax

Mapped types use the syntax

{ [P in K]: T }

Example

// Define an object type interface Person {
name: string;
age: number;
email: string;
}
// Create a mapped type that makes all properties optional type PartialPerson = {
[P in keyof Person]?: Person[P];
};
// Usage const partialPerson: PartialPerson = {
name: "John"

};
// Create a mapped type that makes all properties readonly type ReadonlyPerson = {
readonly [P in keyof Person]: Person[P];
};
// Usage const readonlyPerson: ReadonlyPerson = {
name: "Alice", age: 30, email: "alice@example.com"
};
// readonlyPerson.age = 31; // Error: Cannot assign to 'age' because it is a read-only property

Built-in Mapped Types

Standard Library Utilities

TypeScript includes several useful built - in mapped types:
Partial < T >

Readonly < T >

Pick < T, K >

Omit < T, K >

Record < K, V >

Example interface User {
id: number;
name: string;
email: string;
isAdmin: boolean;
}
// Partial<T> - Makes all properties optional type PartialUser = Partial<User>;

// Required<T> - Makes all properties required type RequiredUser = Required<Partial<User>>;

// Readonly<T> - Makes all properties readonly type ReadonlyUser = Readonly<User>;

// Pick < T, K > - Creates a type with a subset of properties from T

type UserCredentials = Pick<User, "email" | "id">;

// Omit < T, K > - Creates a type by removing specified properties from T

type PublicUser = Omit<User, "id" | "isAdmin">;

// Record<K, T> - Creates a type with specified keys and value types type UserRoles = Record<"admin" | "user" | "guest", string>;

Creating Custom Mapped Types

Basic Custom Mappers

Example

// Base interface interface Product {
id: number;
name: string;
price: number;
inStock: boolean;
}
// Create a mapped type to convert all properties to string type type StringifyProperties<T> = {
[P in keyof T]: string;
};
// Usage type StringProduct = StringifyProperties<Product>;

// Create a mapped type that adds validation functions for each property type Validator<T> = {
[P in keyof T]: (value: T[P]) => boolean;
};

// Usage const productValidator: Validator < Product > = {

id: (id) => id > 0, name: (name) => name.length > 0, price: (price) => price >= 0, inStock: (inStock) => typeof inStock === "boolean"
};

Modifying Property Modifiers

Adding and Removing Modifiers

Example

// Base interface with some readonly and optional properties interface Configuration {
readonly apiKey: string;
readonly apiUrl: string;
timeout?: number;
retries?: number;
}
// Remove readonly modifier from all properties type Mutable<T> = {
-readonly [P in keyof T]: T[P];
};
// Usage type MutableConfig = Mutable<Configuration>;

// Make all optional properties required type RequiredProps<T> = {
[P in keyof T]-?: T[P];
};
// Usage type RequiredConfig = RequiredProps<Configuration>;

Advanced Mapped Types

Combining with Conditional Types

Example

// Base interface interface ApiResponse {
data: unknown;
status: number;
message: string;
timestamp: number;
}

// Conditional mapped type: Convert each numeric property to a formatted string type FormattedResponse < T > = {

[P in keyof T]: T[P] extends number ? string : T[P];
};
// Usage type FormattedApiResponse = FormattedResponse<ApiResponse>;

// Another example: Filter for only string properties type StringPropsOnly < T > = {

[P in keyof T as T[P] extends string ? P : never]: T[P];
};
// Usage type ApiResponseStringProps = StringPropsOnly<ApiResponse>;

Key Takeaways

Mapped types let you transform every property of a type in a consistent way.

Key Concepts

Type Transformation

Property Modifiers