ਇਸ ਨੂੰ ਪੜ੍ਹੋ: "ਜੇ T ਪੈਟਰਨ U[] ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਤਾਂ U ਨੂੰ ਜੋ ਵੀ element type ਹੈ ਉਸ ਨਾਲ ਬਾਂਧ ਦੋ, ਅਤੇ ਇਹ ਵਾਪਸ ਕਰੋ।" infer U ਇੱਕ ਪਲੇਸਹੋਲਡਰ ਦਾ ਐਲਾਨ ਕਰਦਾ ਹੈ ਜੋ compiler ਪੈਟਰਨ ਮਿਲਾ ਕੇ ਭਰਦਾ ਹੈ।
// 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 ਦੇ ਪਿੱਛੇ ਇੰਜਿਨ ਹੈ, ਅਤੇ library magic ਦੇ ਪਿੱਛੇ ਜੋ fetchers ਤੋਂ response types ਜਾਂ components ਤੋਂ props ਨੂੰ derive ਕਰਦਾ ਹੈ।
ਇਹ type code ਨੂੰ ਇੱਕ ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਨੂੰ "ਖੋਲ" ਦਿੰਦਾ ਹੈ ਅਤੇ ਅੰਦਰੂਨੀ ਹਿਸਿਆਂ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ — ਉਹ ਕਿਸਮਾਂ ਲਿਖਣ ਲਈ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਾਧਨ ਜੋ ਹੋਰ ਕਿਸਮਾਂ ਨੂੰ ਢੁਕ ਜਾਂਦੀਆਂ ਹਨ।