Praktyczne zastosowania infer: rozwijanie Promise

Problem rozpakowywania

type Awaited<T> = T extends Promise<infer U> ? U : T;
type A = Awaited<Promise<string>>; // string
type B = Awaited<number>;          // number

Wbudowany typ narzędziowy Awaited

type A = Awaited<Promise<Promise<string>>>; // string
// Handles arbitrary nesting automatically

Rozpakowywanie z własnym limitem głębokości

type DeepAwaited<T> =
  T extends Promise<infer U> ? DeepAwaited<U> : T;
type A = DeepAwaited<Promise<Promise<number>>>; // number

Rozpakowywanie elementów tablic

type Element<T> = T extends (infer U)[] ? U : never;
type A = Element<string[]>; // string
type B = Element<number[]>; // number

Rozpakowywanie typów Observable

type ObservableType<T> = T extends Observable<infer U> ? U : never;
type A = ObservableType<Observable<User>>; // User

Rozpakowywanie typu zwracanego przez funkcję

async function getUser(): Promise<User> { /* ... */ }
type UserResult = Awaited<ReturnType<typeof getUser>>; // User

Rozpakowywanie zagnieżdżonych opakowań

type UnwrapPromiseArray<T> =
  T extends Promise<infer U>
    ? U extends (infer V)[]
      ? V
      : U
    : T;
type A = UnwrapPromiseArray<Promise<User[]>>; // User

Warunkowe rozpakowywanie na podstawie struktury

type MaybeUnwrap<T> =
  T extends Promise<infer U> ? U : T extends (infer V)[] ? V : T;

type A = MaybeUnwrap<Promise<string>>;  // string
type B = MaybeUnwrap<number[]>;         // number
type C = MaybeUnwrap<boolean>;          // boolean

Typowany wrapper do pobierania danych z API

async function fetchData<T>(url: string): Promise<T> {
  const res = await fetch(url);
  return res.json() as T;
}
type UserData = Awaited<ReturnType<typeof fetchData<User>>>; // User

Bezpieczne rozpakowywanie z obsługą błędów

type Ok<T> = { ok: true; value: T };
type Err = { ok: false; error: string };
type ExtractOk<T> = T extends Ok<infer V> ? V : never;
type A = ExtractOk<Ok<number> | Err>; // number

Podsumowanie: rozpakowywanie z infer

Szybkie sprawdzenie

Czego się nauczyłeś