infer ஒரு conditional type உள்ளே பயன்படுத்தப்படுகிறது capture (பிரித்தெடுக்க) மற்றொரு வகைக்குள் இருந்து ஒரு புதிய வகை மாறியாக நீங்கள் பின்னர் பயன்படுத்தலாம். இது வகைகளுக்கான pattern-matching ஆகும்.
<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 பின்னால் இருக்கும் இயந்திரம், மற்றும் fetchers இல் இருந்து பதிலளிக்க வகைகளை பெறும் அல்லது கூறுகள் இல்லாமல் நிர்ணயம் செய்யும் நூலகம் மாயமான பின்னால் உள்ளது.
இது வகை குறியீட்டை "திற" கொள்ள ஒரு சிக்கலான வகை மற்றும் உட்புற பகுதிகள் வெளியேற்ற அனுமதிக்கிறது — பிற வகைகளுக்கு தகவமைக்கும் வகைகளை எழுத மிகவும் சக்திசாலியான கொள்ளை.