infer wird in einem conditional type verwendet, um einen Typ von innerhalb eines anderen Typs zu erfassen (extrahieren) und in eine neue Typvariable zu übernehmen, die Sie dann verwenden können. Es ist Pattern-Matching für Typen.
<T> = T (infer U)[] ? U : ;
A = <[]>;
B = <[]>;
Lesen Sie es so: "Wenn T das Muster U[] erfüllt, binden Sie U an den Elementtyp und geben ihn zurück." infer U deklariert einen Platzhalter, den der Compiler durch Matching ausfüllt.
// the resolved type of a Promise
type Awaited2<T> = T extends Promise<infer R> ? R : T;
type R = Awaited2<Promise<User>>; // User
// a function's return type (this is how ReturnType is built)
type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;
type X = MyReturn<() => number>; // number
// a function's first parameter
type FirstArg<T> = T extends (a: infer A, ...rest: any[]) => any ? A : never;
type UnwrapBoth<T> =
T extends Promise<infer U> ? UnwrapBoth<U> : // recurse to unwrap nested promises
T extends (infer E)[] ? E : T;
Sie können mehrere infers in einem Muster verwenden und sogar rekursiv vorgehen.
infer ist das Herzstück der eingebauten Typen wie ReturnType, Parameters, Awaited und InstanceType und des Bibliotheks-Magic, das Antworttypen von Fetchern oder Props aus Komponenten ableitet.
Es ermöglicht Typcode, einen komplexen Typ "aufzubrechen" und innere Teile herauszuziehen — das mächtigste Werkzeug zum Schreiben von Typen, die sich anderen Typen anpassen.