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