أنماط الاستدلال المتداخلة بعمق

لماذا نحتاج إلى الاستدلال العميق؟

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

العودية الذيلية للـ tuple

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

infer في توزيع أنواع الاتحاد

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

استنتاج tuples المتبقية

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[] }

مراجعة سريعة: الاستدلال العميق

اختبار سريع

ما تعلّمتموه