TypeScript keyof, typeof และ indexed access
3 type operator ที่ใช้คู่กันบ่อยมาก — ทำให้ type “อ้างอิง” กันได้แทนเขียนซ้ำ
keyof — union ของ key
interface User {
id: number;
name: string;
email: string;
}
type UserKey = keyof User;
// "id" | "name" | "email"
function getField(user: User, key: keyof User) {
return user[key]; // number | string | ... (union ของทุก value type)
}keyof กับ index signature:
type StringMap = { [key: string]: number };
type K = keyof StringMap; // string | number (JS แปลง key เป็น string, number index ก็เข้าได้)
type NumberMap = { [key: number]: string };
type K2 = keyof NumberMap; // numbertypeof — ดึง type จากค่า (type query)
ใน บริบท type typeof x = type ของตัวแปร x:
const config = {
host: "localhost",
port: 8080,
debug: true,
};
type Config = typeof config;
// { host: string; port: number; debug: boolean }
function loadConfig(): typeof config {
return { ...config };
}
typeofในบริบท value (if (typeof x === "string")) เป็นคนละอย่าง — อันนั้นคือ JS operator ที่คืน string
typeof + as const:
const ROLES = ["admin", "editor", "viewer"] as const;
type Roles = typeof ROLES; // readonly ["admin", "editor", "viewer"]
type Role = typeof ROLES[number]; // "admin" | "editor" | "viewer"typeof function:
function createUser(name: string, age: number) {
return { name, age, id: crypto.randomUUID() };
}
type CreateUserFn = typeof createUser; // (name: string, age: number) => {...}
type User = ReturnType<typeof createUser>; // { name: string; age: number; id: string }
type Args = Parameters<typeof createUser>; // [name: string, age: number]indexed access — T[K]
ดึง type ของ property:
interface User {
id: number;
name: string;
address: {
city: string;
zip: string;
};
roles: string[];
}
type ID = User["id"]; // number
type Name = User["name"]; // string
type Address = User["address"]; // { city: string; zip: string }
type City = User["address"]["city"]; // string
type Role = User["roles"][number]; // string (element type ของ array)
// หลาย key พร้อมกัน → union
type IdOrName = User["id" | "name"]; // number | string
type AllValues = User[keyof User]; // number | string | {...} | string[]รวมกัน: generic getter ที่ type-safe
function get<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const user = { id: 1, name: "อร", active: true };
const id = get(user, "id"); // number
const name = get(user, "name"); // string
const active = get(user, "active"); // boolean
get(user, "email"); // Error: "email" ไม่ใช่ keyof userK extends keyof T— key ต้องมีจริง (+ autocomplete)- return
T[K]— type ตรงกับ property นั้นเป๊ะ ไม่ใช่ union กว้าง ๆ
setter ที่ type-safe
function set<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
obj[key] = value;
}
set(user, "name", "บอย"); // OK
set(user, "id", "abc"); // Error: string ไม่ assignable กับ numberpattern: derive type จาก object เดียว
// source of truth เดียว
const permissions = {
"post:read": true,
"post:write": false,
"post:delete": false,
"user:manage": false,
} as const;
type Permission = keyof typeof permissions;
// "post:read" | "post:write" | "post:delete" | "user:manage"
function can(perm: Permission): boolean {
return permissions[perm];
}
can("post:read"); // OK
can("post:edit"); // Error — และ autocomplete แสดงตัวเลือกที่ถูกเปลี่ยน permissions object → type Permission อัปเดตอัตโนมัติ
keyof กับ generic constraint
// pluck — ดึง property หนึ่งจาก array ของ object
function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
return items.map((item) => item[key]);
}
const users = [
{ id: 1, name: "อร" },
{ id: 2, name: "บอย" },
];
const names = pluck(users, "name"); // string[]
const ids = pluck(users, "id"); // number[]เรื่องที่คนมักพลาด
- สับสน
typeofใน type context กับ value context —type X = typeof obj(type) vsif (typeof x === ...)(value) keyof Tเมื่อ T มี index signature — ได้string | numberไม่ใช่ key เจาะจงT[K]กับ key ที่ไม่มี — error (ดี); แต่T[string]กับ object ปกติก็ errortypeof arr[number]โดยไม่as const— ได้ element type กว้าง ๆ ไม่ใช่ union ของ literalkeyof typeof objลืมtypeof—keyof obj(obj เป็น value) ผิด; ต้องkeyof typeof objUser["roles"]คาดว่าได้ element type — ได้string[]; ต้องUser["roles"][number]- generic getter ไม่ใช้
K extends keyof T— return type กลายเป็น union กว้าง /any
สรุป
keyof T— union ของ key ทั้งหมดของ T ("id" | "name" | ...)typeof value(ใน type context) — ดึง type จากตัวแปร/ฟังก์ชันที่มีอยู่T[K](indexed access) — type ของ propertyK;T[keyof T]= union ของทุก value type;T[number]= element type ของ array- combo:
keyof typeof obj— union ของ key จาก object จริง (source of truth เดียว) - generic getter:
<T, K extends keyof T>(obj: T, key: K): T[K]— type-safe เป๊ะ ReturnType<typeof fn>/Parameters<typeof fn>— ดึง type จากฟังก์ชัน
บทถัดไปว่าด้วย mapped types — { [K in keyof T]: ... } วิธีสร้าง type ใหม่จาก type เดิมทีละ key