TypeScript mapped types



mapped type = “วนทุก key ของ type แล้วสร้าง type ใหม่” — เหมือน array.map() แต่สำหรับ type

รูปแบบพื้นฐาน

type MyReadonly<T> = {
  [K in keyof T]: T[K];
};

อ่าน: “สำหรับทุก key K ใน keyof T — property K มี type T[K]“

{ [K in keyof T]: T[K] } = สำเนาของ T เป๊ะ ๆ — ตัวมันเองไม่มีประโยชน์ แต่เป็นฐานให้แปลง

เปลี่ยน type ของทุก property

type Stringify<T> = {
  [K in keyof T]: string;
};

interface User {
  id: number;
  age: number;
  active: boolean;
}

type UserForm = Stringify<User>;
// { id: string; age: string; active: string }   — ทุกอย่างเป็น string (form input)
// wrap ทุก property ใน getter
type Getters<T> = {
  [K in keyof T]: () => T[K];
};

type UserGetters = Getters<User>;
// { id: () => number; age: () => number; active: () => boolean }

modifier: readonly และ ?

type MyReadonly<T> = {
  readonly [K in keyof T]: T[K];
};

type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

type ReadonlyUser = MyReadonly<User>;
// { readonly id: number; readonly age: number; readonly active: boolean }

เพิ่ม/ลบ modifier ด้วย + และ –

// ลบ readonly ออก
type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};

// ลบ ? ออก (ทำให้ required)
type MyRequired<T> = {
  [K in keyof T]-?: T[K];
};

interface Config {
  readonly host: string;
  port?: number;
}

type MutableConfig = Mutable<Config>;   // { host: string; port?: number }
type FullConfig = MyRequired<Config>;   // { readonly host: string; port: number }

+ (เพิ่ม, default) หรือ - (ลบ) นำหน้า readonly / ?

key remapping — as

เปลี่ยนชื่อ key ระหว่าง map ด้วย as:

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type UserGetters = Getters<User>;
// { getId: () => number; getAge: () => number; getActive: () => boolean }

กรอง key ออก (map เป็น never = ตัดทิ้ง):

// เอาเฉพาะ property ที่เป็น function
type Methods<T> = {
  [K in keyof T as T[K] extends Function ? K : never]: T[K];
};

interface Service {
  name: string;
  start(): void;
  stop(): void;
  config: object;
}

type ServiceMethods = Methods<Service>;
// { start(): void; stop(): void }
// ลบ key ที่ต้องการ (แบบ Omit)
type RemoveKey<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P];
};

type UserWithoutId = RemoveKey<User, "id">;
// { age: number; active: boolean }

mapped type กับ union ของ literal (ไม่ใช่ keyof T)

type Flags = {
  [K in "read" | "write" | "execute"]: boolean;
};
// { read: boolean; write: boolean; execute: boolean }

// = Record<"read" | "write" | "execute", boolean>

Record<K, V> จริง ๆ คือ mapped type: type Record<K extends keyof any, V> = { [P in K]: V }

mapped type ที่ใช้จริง

// nullable ทุก field
type Nullable<T> = {
  [K in keyof T]: T[K] | null;
};

// deep partial (recursive)
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
};

// event map → handler map
type EventMap = {
  click: MouseEvent;
  keydown: KeyboardEvent;
  scroll: Event;
};

type EventHandlers = {
  [K in keyof EventMap as `on${Capitalize<K>}`]: (event: EventMap[K]) => void;
};
// { onClick: (e: MouseEvent) => void; onKeydown: (e: KeyboardEvent) => void; onScroll: (e: Event) => void }

เรื่องที่คนมักพลาด

  • ลืม keyof — { [K in T]: ... } เมื่อ T ไม่ใช่ union ของ key = error; ต้อง [K in keyof T]
  • [K in keyof T as ...] remap เป็น key ที่ชนกัน — key ซ้ำ merge เป็น union
  • remap เป็น never ตัดทิ้ง — เป็น feature (Omit ใช้เทคนิคนี้) แต่มือใหม่งง
  • mapped type กับ tuple/array — ได้ผลแปลก (map แต่ละ index + length, map, …); ใช้เทคนิคเฉพาะสำหรับ tuple
  • T[K] ใน mapped type แล้วลืมว่า K วนทุกตัว — T[K] = type ของ property ปัจจุบัน
  • Capitalize<K> โดย K ไม่ใช่ string — ต้อง Capitalize<string & K> (K อาจเป็น string | number | symbol)

สรุป

  • mapped type { [K in keyof T]: NewType } — วนทุก key ของ T สร้าง type ใหม่
  • เปลี่ยน value type: { [K in keyof T]: T[K] | null }, { [K in keyof T]: () => T[K] }
  • modifier: readonly [K in keyof T] (เพิ่ม), -readonly (ลบ), [K in keyof T]? (เพิ่ม), [K in keyof T]-? (ลบ)
  • key remapping [K in keyof T as NewKey] — เปลี่ยนชื่อ (`get${...}`), กรอง (as ... ? K : never)
  • Record<K, V> = mapped type บน union ของ literal
  • Partial/Readonly/Required/Pick/Omit ทั้งหมดสร้างด้วย mapped type (บทที่ 16)

บทถัดไปว่าด้วย conditional types — T extends U ? X : Y และ infer — logic ในระดับ type