TypeScript Mapped Types Cheat Sheet

Covers the [K in keyof T] syntax, key remapping with as, readonly/optional modifiers, and template literal key patterns.

1 PageAdvancedApr 6, 2026

Basic Mapped Type Syntax

Iterate over a union of keys and build a new object type from them.

typescript

type User = { id: number; name: string; email: string };type ReadonlyUser = { readonly [K in keyof User]: User[K] };type PartialUser  = { [K in keyof User]?: User[K] };type Stringify<T> = { [K in keyof T]: string };type UserStrings = Stringify<User>;// { id: string; name: string; email: string }

Adding & Removing Modifiers

Prefix with `+`/`-` to explicitly add or strip `readonly`/`?`.

typescript

type Mutable<T> = { -readonly [K in keyof T]: T[K] };type Required2<T> = { [K in keyof T]-?: T[K] };type Optional<T>  = { [K in keyof T]+?: T[K] };interface Config {    readonly host: string;    port?: number;}type WritableConfig = Mutable<Config>;   // host is no longer readonlytype FullConfig = Required2<Config>;      // port is no longer optional

Key Remapping with `as`

TS 4.1+ lets you transform key names during mapping, or filter keys out entirely.

typescript

type Getters<T> = {    [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]};interface Person { name: string; age: number }type PersonGetters = Getters<Person>;// { getName: () => string; getAge: () => number }// Filter out keys by mapping them to `never`:type OmitByType<T, V> = {    [K in keyof T as T[K] extends V ? never : K]: T[K]};type NonStringProps = OmitByType<Person, string>; // { age: number }

Mapped Type Syntax Reference

Building blocks for constructing mapped types.

[K in keyof T]- iterates every key of T, K bound to each key
as- remaps the resulting key name (TS 4.1+); map to never to drop a key
readonly / -readonly- add or strip the readonly modifier
? / -?- add or strip optionality
T[K]- indexed access to get the value type for key K
keyof T- union of all property names of T, the usual source for K

Pro Tip

Combine key remapping with template literal types (e.g. `on${Capitalize<K>}`) to auto-generate event-handler-shaped types from a props interface — this is exactly how libraries type their `onX` callback props.

Was this cheat sheet helpful?

TypeScript Conditional Types Cheat Sheet

C# Minimal APIs Cheat Sheet

Explore Topics

#TypeScriptMappedTypes#TypeScriptMappedTypesCheatSheet#Programming#Advanced#BasicMappedTypeSyntax#AddingRemovingModifiers#KeyRemappingWithAs#MappedTypeSyntaxReference#CheatSheet#SkillVeris

Sri Hayavadhana Info-Tech

Professional Web Designing Services