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 ไม่มี .length

T 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 ของ user

K 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 ที่มีจริง; return T[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>)