जेनेरिक्सले तपाईंलाई पुनः प्रयोज्य कोड लेख्न दिन्छ जो एक प्रकार द्वारा प्यारामिटराइज गरिएको छ — एक "प्रकार चर" जो कोड प्रयोग गर्दा भरिन्छ। तिनीहरूले तपाईंलाई प्रकार सुरक्षा गुमाएर पुनः प्रयोग दिन्छन् (विकल्प, any, हराउछ)।
(): { arr[]; }
first<T>(: T[]): T { arr[]; }
n = ([, , ]);
s = ([, ]);
T एक प्लेसहोल्डर हो; TypeScript तर्कबाट अनुमान गर्छ, त्यसैले रिटर्न प्रकार सटीक छ — first([1,2])ले any होइन बरु number दिन्छ।
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]
जेनेरिक्सले TypeScriptमा लगभग हरेक पुनः प्रयोज्य अमूर्तलाई शक्ति दिन्छ: Array<T>, Promise<T>, Map<K,V>, React को useState<T>, डेटा-फेचिङ उपयोगिताहरू, र संग्रहहरू।
तिनीहरूले एक कार्यान्वयनलाई धेरै प्रकारहरूको लागि काम गर्न दिन्छन्, जबकि सिरैदेखि अन्तसम्म पूर्ण प्रकार जानकारी सংरक्षित राख्छन् — इनपुट र आउटपुट प्रकारहरू बीचको सम्बन्ध संरक्षित छ, मेटिइएको छैन।