TypeScript generics
ปัญหาที่ generics แก้
// ❌ any — เสีย type
function first(arr: any[]): any {
return arr[0];
}
const x = first([1, 2, 3]); // x: any — เสียแล้ว
// ❌ เขียนหลายเวอร์ชัน
function firstNumber(arr: number[]): number | undefined { return arr[0]; }
function firstString(arr: string[]): string | undefined { return arr[0]; }generic function
function first<T>(arr: T[]): T | undefined {
return arr[0];
}
const a = first([1, 2, 3]); // a: number | undefined — T infer เป็น number
const b = first(["x", "y"]); // b: string | undefined
const c = first([{ id: 1 }]); // c: { id: number } | undefined<T> = type parameter — placeholder ที่ TS แทนที่ด้วย type จริงตอนเรียก ความสัมพันธ์ input↔output ถูกรักษาไว้ (array ของ T → คืน T)
type inference — ไม่ต้องระบุ T
first([1, 2, 3]); // TS infer T = number จาก argument
first<number>([1, 2, 3]); // ระบุเองก็ได้ (นาน ๆ ต้องทำ)TS infer T จาก argument ที่ส่งเข้า — เขียน <number> เมื่อ infer ไม่ได้ (เช่น [] ว่าง) หรืออยากบังคับ
generic หลายตัว
function pair<A, B>(a: A, b: B): [A, B] {
return [a, b];
}
const p = pair("age", 25); // [string, number]
function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
return arr.map(fn);
}
const lengths = map(["a", "bb", "ccc"], (s) => s.length); // number[]generic constraint — extends
จำกัดว่า T ต้อง “อย่างน้อยเป็น” อะไร:
// ❌ ไม่มี constraint — เข้าถึง .length ไม่ได้ (T อาจไม่มี)
function longest<T>(a: T, b: T): T {
return a.length > b.length ? a : b;
// ~~~~~~ Property 'length' does not exist on type 'T'
}
// ✅ constraint
function longest<T extends { length: number }>(a: T, b: T): T {
return a.length >= b.length ? a : b;
}
longest("abc", "de"); // string (มี .length)
longest([1, 2], [3, 4, 5]); // number[]
longest(10, 20); // Error: number ไม่มี .lengthT extends X = “T ต้อง assignable กับ X” — ในฟังก์ชัน T ยังเป็น type จริงที่ส่งมา (ไม่ใช่ X)
constraint ที่ใช้บ่อย: keyof
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
const user = { name: "อร", age: 25, active: true };
getProperty(user, "name"); // string
getProperty(user, "age"); // number
getProperty(user, "email"); // Error: "email" ไม่ใช่ key ของ userK extends keyof T — key ต้องเป็น property ที่มีจริง; return T[K] = type ของ property นั้น (บทที่ 13)
default type parameter
interface ApiResponse<T = unknown> {
data: T;
status: number;
}
const r1: ApiResponse = { data: "?", status: 200 }; // T = unknown
const r2: ApiResponse<User> = { data: user, status: 200 }; // T = User
function createState<T = undefined>(initial?: T) {
let value = initial;
return {
get: () => value,
set: (v: T) => { value = v; },
};
}generic ที่ infer ไม่ได้ → any / unknown
function box<T>(): { value: T | undefined } {
return { value: undefined };
}
const b = box(); // T infer ไม่ได้ (ไม่มี argument) → T = unknown
const b2 = box<string>(); // ระบุเองตัวอย่าง generic function ที่ใช้จริง
// pick property ที่ต้องการ
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
const result = {} as Pick<T, K>;
for (const key of keys) {
result[key] = obj[key];
}
return result;
}
const user = { id: 1, name: "อร", password: "secret", email: "a@b.com" };
const publicUser = pick(user, ["id", "name", "email"]);
// { id: number; name: string; email: string } — ไม่มี password
// group by key
function groupBy<T, K extends string | number>(
arr: T[],
keyFn: (item: T) => K,
): Record<K, T[]> {
const result = {} as Record<K, T[]>;
for (const item of arr) {
const key = keyFn(item);
(result[key] ??= []).push(item);
}
return result;
}generic ในตำแหน่งอื่น
// arrow function
const identity = <T>(x: T): T => x; // ต้องมี trailing comma <T,> ในไฟล์ .tsx
// generic method ใน object
const utils = {
clone<T>(obj: T): T {
return structuredClone(obj);
},
};เมื่อไม่ควรใช้ generic
// ❌ generic ที่ใช้ครั้งเดียว ไม่มีความสัมพันธ์ = ไม่มีประโยชน์
function log<T>(value: T): void {
console.log(value);
}
// เทียบเท่า: function log(value: unknown): voidกฎ: generic คุ้มค่าเมื่อ type parameter ปรากฏอย่างน้อย 2 ที่ (input กับ output, หรือหลาย input) — เพื่อ “เชื่อม” type เข้าด้วยกัน ถ้าปรากฏที่เดียว ใช้ unknown พอ
เรื่องที่คนมักพลาด
- ใช้ generic ที่ปรากฏที่เดียว — ไม่ต่างจาก
unknown; ต้องเชื่อม input↔output - ไม่ใส่ constraint แล้วเข้าถึง property ของ T —
Tอาจไม่มี;<T extends {...}> - ระบุ
<Type>เองทั้งที่ infer ได้ — ปล่อยให้ infer T extends keyof Tสับสน — ควรเป็น 2 param:<T, K extends keyof T><T>ใน.tsxไฟล์ — ชนกับ JSX; ใช้<T,>หรือ<T extends unknown>- คิดว่า
T extends Xแปลว่า T กลายเป็น X — T ยังเป็น type จริงที่ส่งมา (subtype ของ X) - generic constraint กว้างเกิน (
T extends object) — ไม่ช่วยอะไร; เจาะจง
สรุป
function f<T>(x: T): T— type parameter เชื่อม input↔output; TS infer T จาก argument- generic คุ้มค่าเมื่อ T ปรากฏ ≥ 2 ที่ (ไม่งั้นใช้
unknown) - constraint
<T extends X>— T ต้อง assignable กับ X (เข้าถึง property ของ X ได้ในฟังก์ชัน) <K extends keyof T>— key ที่มีจริง; returnT[K]- default
<T = unknown>— ค่าเริ่มต้นเมื่อไม่ระบุ/infer ไม่ได้ - ใน
.tsxใช้<T,>(trailing comma) กัน JSX ชน
บทถัดไปว่าด้วย generic type — generic interface/class และ built-in generic (Array<T>, Map<K,V>, Promise<T>)