Generics ఒక టైప్ ద్వారా పారామితిపరచిన పునర్ବ్యవహారయోగ్య కోడ్ రాయడానికి మిమ్మల్ని అనుమతిస్తుంది — కోడ్ ఉపయోగించినప్పుడు నింపబడే "టైప్ వేరియబల్". అవి టైప్ సేఫ్టీ కోల్పోకుండా పునర్ବ్యవహారం ఇస్తాయి (ప్రత్యామ్నాయం, any, దానిని కోల్పోతుంది).
(): { arr[]; }
first<T>(: T[]): T { arr[]; }
n = ([, , ]);
s = ([, ]);
T ఒక ప్లేస్హోల్డర్; TypeScript దీనిని arguments నుండి తెలుసుకుంటుంది, కాబట్టి రిటర్న్ టైప్ ఖచ్చితమైనది — first([1,2]) ఒక number ఇస్తుంది, any కాదు.
interface ApiResponse<T> { data: T; status: number; }
const res: ApiResponse<User> = await getUser(); // res.data is User
class Box<T> {
constructor(private value: T) {}
get(): T { return this.value; }
}
const box = new Box(123); // Box<number>
function pair<K, V>(k: K, v: V): [K, V] { return [k, v]; }
pair("id", 42); // [string, number]
Generics TypeScriptలో దాదాపు ప్రతిটి పునర్ବ్యవహారయోగ్య చిత్రణను శక్తిచేస్తుంది: Array<T>, Promise<T>, Map<K,V>, React యొక్క useState<T>, డేటా-ఫెచింగ్ యుటిలిటీలు, మరియు సేకరణలు.
పూర్తి టైప్ సమాచారాన్ని చివరి నుండి చివరి వరకు సంరక్షిస్తూ ఒక అమలు అనేక టైపుల కోసం పనిచేయడానికి అనుమతిస్తుంది — ఇన్పుట్ మరియు అవుట్పుట్ టైపుల మధ్య సంబంధం సంరక్షించబడుతుంది, చెదిరిపోవు.