infer ఒక conditional type లో ఉపయోగించబడుతుంది ఒక వకిలుగా capture (సంగ్రహించు) ఇతర రకం నుండి లోపల ఒక కొత్త టైప్ వేరియబల్ లోకి మీరు తర్వాత ఉపయోగించవచ్చు. ఇది రకాలకు pattern-matching.
ts
<T> = T (infer U)[] ? U : ;
A = <[]>;
B = <[]>;
కింది విధంగా చదవండి: "if 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;
మీరు ఒక నమూనాలో బహుళ infers ఉపయోగించవచ్చు మరియు కూడా పునరావృత చేయవచ్చు.
infer ఉంటుంది యంత్రం వెనుక నిర్మిత రకాలు ReturnType, Parameters, Awaited, మరియు InstanceType, మరియు వెనుక లైబ్రరీ మాయ ఇది తీసుకోవు ప్రతిస్పందన రకాలు కొటేవర్లు నుండి లేదా props సమాచారం నుండి.
ఇది అనుమతిస్తుంది రకం కోడ్ "తెరువు" ఒక సంక్లిష్ట రకం మరియు త్రీ బయటకు లోపలి ముక్కలు — అత్యంత శక్తిశాలీ సాధనం రకాలు వ్రాసేందుకు అంటే స్థిరం ఇతర రకాలకు.