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);            // Error

generic 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 | undefined

generic 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: string

generic 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 | undefined
  • Record<string, T> แล้วเข้าถึง key ที่ไม่มี — TS ไม่เตือน (เว้น noUncheckedIndexedAccess)
  • สร้าง generic class ที่ไม่มี type parameter ในหลาย method — อาจไม่ต้องเป็น generic
  • Result type แล้วลืม narrow — เข้าถึง .value ก่อนเช็ค .ok
  • Promise<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/Set operations คืน 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