TypeScript generic type, class และ built-in
generic interface
interface Box<T> {
value: T;
getValue(): T;
setValue(v: T): void;
}
const numberBox: Box<number> = {
value: 42,
getValue() { return this.value; },
setValue(v) { this.value = v; },
};
const stringBox: Box<string> = { /* ... */ };generic class
class Stack<T> {
private items: T[] = [];
push(item: T): void {
this.items.push(item);
}
pop(): T | undefined {
return this.items.pop();
}
peek(): T | undefined {
return this.items.at(-1);
}
get size(): number {
return this.items.length;
}
}
const numbers = new Stack<number>();
numbers.push(1);
numbers.push(2);
const top = numbers.pop(); // number | undefined
const strings = new Stack<string>();
strings.push("hello");
// strings.push(42); // Errorgeneric type alias
type Nullable<T> = T | null;
type Pair<T> = [T, T];
type Dictionary<T> = Record<string, T>;
type AsyncFn<Args extends unknown[], Return> = (...args: Args) => Promise<Return>;
const scores: Dictionary<number> = { math: 90, science: 85 };
const coords: Pair<number> = [10, 20];built-in generic types — ใช้ทุกวัน
Array<number> // = number[]
ReadonlyArray<string> // = readonly string[]
Map<string, number> // Map: get/set/has/delete
const m = new Map<string, User>();
m.set("u1", user);
const u = m.get("u1"); // User | undefined
Set<string>
const s = new Set<number>([1, 2, 3]);
Promise<Response> // async result
Record<string, number> // = { [key: string]: number }
Record<"a" | "b", boolean> // = { a: boolean; b: boolean }
Partial<User> // ทุก field เป็น optional (บทที่ 16)
Pick<User, "id" | "name">Result type — pattern ที่พบบ่อย
type Result<T, E = Error> =
| { ok: true; value: T }
| { ok: false; error: E };
function parseJSON<T>(text: string): Result<T> {
try {
return { ok: true, value: JSON.parse(text) as T };
} catch (e) {
return { ok: false, error: e instanceof Error ? e : new Error(String(e)) };
}
}
const result = parseJSON<{ name: string }>('{"name":"อร"}');
if (result.ok) {
console.log(result.value.name); // narrow → มี value
} else {
console.error(result.error.message); // narrow → มี error
}Result บังคับให้ผู้เรียกจัดการทั้งสองกรณี (แทน exception ที่ลืม catch ได้) — บทที่ 27
generic container class
class Cache<K, V> {
private store = new Map<K, { value: V; expiresAt: number }>();
constructor(private ttlMs: number) {}
set(key: K, value: V): void {
this.store.set(key, { value, expiresAt: Date.now() + this.ttlMs });
}
get(key: K): V | undefined {
const entry = this.store.get(key);
if (!entry) return undefined;
if (Date.now() > entry.expiresAt) {
this.store.delete(key);
return undefined;
}
return entry.value;
}
}
const userCache = new Cache<string, User>(60_000);
userCache.set("u1", user);
const cached = userCache.get("u1"); // User | undefinedgeneric constraint ใน class
class Repository<T extends { id: string }> {
private items = new Map<string, T>();
save(item: T): void {
this.items.set(item.id, item); // เข้าถึง .id ได้เพราะ constraint
}
findById(id: string): T | undefined {
return this.items.get(id);
}
}
const userRepo = new Repository<User>(); // User ต้องมี id: stringgeneric type ที่รับ generic (higher-kinded — TS ไม่มีเต็มรูปแบบ)
// TS ไม่รองรับ higher-kinded type ตรง ๆ (ทำ Functor<F> ไม่ได้)
// แต่ pattern ทั่วไปทำได้:
type Wrapped<T> = { data: T; meta: { timestamp: number } };
type ApiList<T> = Wrapped<T[]>;
type ApiItem<T> = Wrapped<T>;static member กับ generic class
class Container<T> {
// static ใช้ T ไม่ได้ — static ไม่ผูกกับ instance/type parameter
// static default: T; // Error
static create<U>(value: U): Container<U> {
const c = new Container<U>();
c.value = value;
return c;
}
value!: T;
}เรื่องที่คนมักพลาด
new Stack()โดยไม่ระบุ/infer T — T =unknown; ระบุnew Stack<number>()หรือ push ค่าให้ TS infer- static member ใช้ type parameter ของ class — ทำไม่ได้ (static ไม่ผูกกับ instance)
Map.get()แล้วใช้ต่อโดยไม่เช็ค — คืนV | undefinedRecord<string, T>แล้วเข้าถึง key ที่ไม่มี — TS ไม่เตือน (เว้นnoUncheckedIndexedAccess)- สร้าง generic class ที่ไม่มี type parameter ในหลาย method — อาจไม่ต้องเป็น generic
Resulttype แล้วลืม narrow — เข้าถึง.valueก่อนเช็ค.okPromise<T>แล้วลืมawait— ได้Promise<T>ไม่ใช่T(บทที่ 26)
สรุป
- generic
interface/class/type— เก็บ type parameter, ระบุตอนใช้ (Box<number>,new Stack<string>()) - built-in:
Array<T>,ReadonlyArray<T>,Map<K,V>,Set<T>,Promise<T>,Record<K,V> Map.get/Setoperations คืนT | undefined— เช็คก่อนใช้Result<T, E>= discriminated union{ok: true; value} | {ok: false; error}— บังคับจัดการทั้งสองกรณี- generic class + constraint:
class Repo<T extends { id: string }> - static member ใช้ class type parameter ไม่ได้
บทถัดไปว่าด้วย keyof, typeof และ indexed access — เครื่องมือดึง type ออกจากค่าและ object