Mapped types transform existing types by iterating over their keys using 'in keyof' syntax. They can modify properties (make optional, readonly), rename keys, and filter properties. Built-in utilities like Partial, Required, and Pick use mapped types.
Mapped Type Syntax:
{ [K in keyof T]: T[K] }: Basic mapping+ / - modifiers for optional and readonlyas clause for key remappingModifiers:
readonly: Make properties readonly?: Make properties optional-readonly: Remove readonly-?: Remove optional (make required)Key Remapping:
as clause to filter or rename keysnever to filter out keys// Identity mapping (copies type)
type Identity<T> = {
[K in keyof T]: T[K];
};
// Make all properties optional (Partial)
type MyPartial<T> = {
[K in keyof T]?: T[K];
};
// Make all properties required (Required)
type MyRequired<T> = {
[K in keyof T]-?: T[K]; // -? removes optional
};
// Make all properties readonly (Readonly)
type MyReadonly<T> = {
readonly [K in keyof T]: T[K];
};
// Remove readonly
type Mutable<T> = {
-readonly [K in keyof T]: T[K];
};
// Example usage
interface User {
readonly id: number;
name?: string;
email: string;
}
type MutableUser = Mutable<User>;
// { id: number; name?: string; email: string } - id no longer readonly
type RequiredUser = MyRequired<User>;
// { readonly id: number; name: string; email: string } - name required