infer એ conditional type માં વપરાય છે જેથી કોઈ પણ પ્રકાર પાસેથી એક નવો પ્રકાર ચલ કેપ્ચર (અર્ક) કરી શકાય જેનો પછીથી ઉપયોગ કરી શકાય. તે પ્રકારો માટે પેટર્ન-મેચિંગ છે.
ts
<T> = T (infer U)[] ? U : ;
A = <[]>;
B = <[]>;
તેને આ રીતે વાંચો: "જો T એ U[] નો પેટર્ન સાથે મેળ ખાય, તો U ને તત્વ પ્રકાર જે પણ હોય તેના સાથે બાંધો, અને તેને રિટર્ન કરો." infer U એક પ્લેસહોલ્ડર જાહેર કરે છે જેને કમ્પાઇલર મેચિંગ દ્વારા ભરે છે.
// 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;
તમે એક જ પેટર્નમાં કેટલાક infer બાપટ ઉપયોગ કરી શકો છો અને તેમાં પુનરાવર્તન પણ કરી શકો છો.
infer એ બિલ્ટ-ઇન પ્રકારો જેમ કે ReturnType, Parameters, Awaited, અને InstanceType પાછળનું મોટર છે, અને તે લાઇબ્રેરી જાદુ પાછળ છે જે ફેચર્સમાંથી પ્રતિભાવ પ્રકારો અથવા ઘટકોમાંથી props મેળવે છે.
તે પ્રકાર કોડને એક જટિલ પ્રકાર "ખોલવા" અને આંતરિક ભાગો બહાર કાઢવાની તક આપે છે — જે પ્રકારો લખવા માટે સૌથી શક્તિશાળી સાધન છે જે અન્ય પ્રકારો સાથે અનુકૂલ થાય છે.