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;  // number

typeof — ดึง 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 user
  • K 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 กับ number

pattern: 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) vs if (typeof x === ...) (value)
  • keyof T เมื่อ T มี index signature — ได้ string | number ไม่ใช่ key เจาะจง
  • T[K] กับ key ที่ไม่มี — error (ดี); แต่ T[string] กับ object ปกติก็ error
  • typeof arr[number] โดยไม่ as const — ได้ element type กว้าง ๆ ไม่ใช่ union ของ literal
  • keyof typeof obj ลืม typeof — keyof obj (obj เป็น value) ผิด; ต้อง keyof typeof obj
  • User["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 ของ property K; 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