Generics என்றால் என்ன மற்றும் அவை ஏன் பயனுள்ளவை?

Question

Accepted Answer

**Generics** ஒரு வகையால் அளவுருவாக்கப்பட்ட மறுபயன்பாட்டு குறியீட்டை எழுத உங்களை அனுமதிக்கிறது — குறியீடு பயன்படுத்தப்படும் போது நிரப்பப்படும் "வகை மாறி". அவை **வகை பாதுகாப்பை இழக்காமல்** மறுபயன்பாட்டை வழங்குகிறது (`any`ன் மாற்று வழிமுறை அதை இழக்கிறது). ```ts // Without generics you'd choose between repetition or `any`: function firstAny(arr: any[]): any { return arr[0]; } // loses the element type // With a generic, the type flows through: function first(arr: T[]): T { return arr[0]; } const n = first([1, 2, 3]); // T inferred as number → n: number const s = first(["a", "b"]); // T inferred as string → s: string ``` `T` ஒரு இடப்பிடிப்பு; TypeScript **இதை** வாதத்திலிருந்து **அனுமானிக்கிறது**, எனவே வகை திரும்பப் பெறுவது துல்லியமாக உள்ளது — `first([1,2])` ஒரு `number` கொடுக்கிறது, `any` அல்ல. ## Generic வகைகள் மற்றும் வகுப்புகள் ```ts interface ApiResponse { data: T; status: number; } const res: ApiResponse = await getUser(); // res.data is User class Box { constructor(private value: T) {} get(): T { return this.value; } } const box = new Box(123); // Box ``` ## பல வகை அளவுருக்கள் ```ts function pair(k: K, v: V): [K, V] { return [k, v]; } pair("id", 42); // [string, number] ``` ## ஏன் இது முக்கியமானது Generics TypeScript இல் கிட்டத்தட்ட ஒவ்வொரு மறுபயன்பாட்டு சுருக்கத்தையும் இயக்குகிறது: `Array`, `Promise`, `Map`, React இன் `useState`, தரவு-பெறுதல் பயன்பாடுகள், மற்றும் சேகரणங்கள். பல வகைகளுக்கு ஒரு நிரல்படுத்தல் செயல்பட உங்களை அனுமதிக்கிறது, அதே போது முழு வகை தகவலையும் முடிவிலிருந்து முடிவு வரை பாதுகாக்கிறது — உள்ளீடு மற்றும் வெளியீட்டு வகைகளுக்கு இடையிலான உறவு பாதுகாக்கப்படுகிறது, அழிக்கப்படவில்லை.