รูปแบบการอนุมานชนิดที่ซ้อนกันลึก

เหตุใดจึงต้องอนุมานเชิงลึก

type DeepUnwrap<T> =
  T extends Promise<infer U>
    ? DeepUnwrap<U>
    : T;

type A = DeepUnwrap<Promise<Promise<string>>>; // string

ชนิดข้อมูลแบบมีเงื่อนไขแบบเวียนเกิด

type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // string

การอนุมานจาก泛型ที่ซ้อนกัน

type InnerValue<T> =
  T extends Map<any, infer V>
    ? V extends Set<infer S>
      ? S
      : V
    : T;
type C = InnerValue<Map<string, Set<number>>>; // number

ชนิดข้อมูลคุณสมบัติของออบเจ็กต์เชิงลึก

type DeepGet<T, K extends keyof T> =
  T[K] extends object ? T[K] : never;

type Nested = { user: { profile: { name: string } } };
type Profile = DeepGet<Nested, "user">; // { profile: { name: string } }

การแยกชนิดข้อมูลสมาชิกอาร์เรย์เชิงลึก

type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // number

การเวียนเกิดส่วนท้ายของทูเพิล

type Last<T extends any[]> =
  T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3

ขีดจำกัดความลึกและข้อควรพิจารณาในการใช้งานจริง

// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chains

การอนุมานในการแจกแจงยูเนียน

type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | boolean

การอนุมานทูเพิลส่วนที่เหลือ

type Init<T extends any[]> =
  T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]

ตัวอย่างจากการใช้งานจริง: ผลลัพธ์ API ที่ซ้อนกัน

type ApiResponse<T> = { data: T; status: number };
type UnwrapApi<T> = T extends ApiResponse<infer D> ? D : T;
type H = UnwrapApi<ApiResponse<{ users: string[] }>>; // { users: string[] }

สรุป: การอนุมานเชิงลึก

ตรวจสอบอย่างรวดเร็ว

สิ่งที่คุณได้เรียนรู้