ข้อจำกัดเจเนอริก: การจำกัดพารามิเตอร์ชนิดให้แคบลง

ยินดีต้อนรับ

ทบทวนข้อจำกัด

function len<T extends { length: number }>(val: T): number {
  return val.length;
}

การจำกัดให้มีเมธอดเฉพาะ

interface Stringable { toString(): string; }
function stringify<T extends Stringable>(val: T): string {
  return val.toString();
}

การอนุมานจากข้อจำกัด

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map(item => item[key]);
}
const names = pluck(users, 'name'); // string[]

ข้อจำกัดแบบชนิดระดับสูง (จำลอง)

การจำกัดให้เป็นประเภทพื้นฐาน

type Primitive = string | number | boolean | bigint | symbol | null | undefined;
function isPrimitive<T extends Primitive>(val: T): true { return true; }

ข้อจำกัดแบบเรียกซ้ำ

interface Comparable<T> { compareTo(other: T): number; }
function sort<T extends Comparable<T>>(items: T[]): T[] {
  return [...items].sort((a, b) => a.compareTo(b));
}

ข้อจำกัดพร้อมค่าเริ่มต้น

function process<T extends object = Record<string, unknown>>(data: T): void {
  console.log(Object.keys(data));
}

T extends Record<string, unknown>

function getValue<T extends Record<string, unknown>>(obj: T, key: string): unknown {
  return obj[key];
}

การอนุมานข้อจำกัดในประเภทค่าที่ส่งคืน

function firstKey<T extends object>(obj: T): keyof T {
  return Object.keys(obj)[0] as keyof T;
}

เครื่องมือ NoInfer (TS 5.4)

function createState<T>(initial: T, fallback: NoInfer<T>): T {
  return initial ?? fallback;
}

ตรวจสอบความเข้าใจ

สรุป