ఫండమెంటల్ జెనరిక్స్

జెనరిక్స్ (జెనరిక్ ప్రోగ్రామింగ్) టైప్‌స్క్రిప్ట్ యొక్క అత్యంత శక్తివంతమైన లక్షణాలలో ఒకటి. గరిష్ట రకం భద్రతను కొనసాగిస్తూ మరియు any వినియోగాన్ని నివారిస్తూ విభిన్న డేటా రకాలతో పని చేయగల సౌకర్యవంతమైన, పునర్వినియోగపరచదగిన భాగాలు, విధులు మరియు ఇంటర్‌ఫేస్‌లను వ్రాయడానికి అవి మిమ్మల్ని అనుమతిస్తాయి.

సాధారణ విధులు

రకాల కోసం వేరియబుల్‌గా జెనరిక్ గురించి ఆలోచించండి. దానికి పంపబడిన విలువను ఆర్గ్యుమెంట్‌గా తిరిగి ఇచ్చే ఫంక్షన్‌ని పరిశీలిద్దాం:

function identity<T>(arg: T): T {
  return arg;
}

T అక్షరం (Typeకి చిన్నది) రకానికి ప్లేస్‌హోల్డర్. మేము identityకి కాల్ చేసినప్పుడు, TypeScript ఆమోదించబడిన ఆర్గ్యుమెంట్ రకాన్ని సంగ్రహిస్తుంది మరియు స్వయంచాలకంగా Tని ఆ రకానికి సెట్ చేస్తుంది:

const str = identity<string>('Hello'); // T is string
const num = identity(42); // T is number (automatically inferred!)

సాధారణ ఇంటర్‌ఫేస్‌లు మరియు మారుపేర్లు

జెనరిక్ కంటైనర్‌లు లేదా డేటా స్ట్రక్చర్‌లను నిర్వచించడానికి ఇంటర్‌ఫేస్‌లు మరియు టైప్ మారుపేర్లకు కూడా జెనరిక్స్ వర్తించవచ్చు:

interface Box<T> {
  content: T;
}

const stringBox: Box<string> = { content: 'TypeScript' };
const numberBox: Box<number> = { content: 42 };

బహుళ రకం పారామితులు

మేము బహుళ రకం వేరియబుల్‌లను ఉపయోగించే ఫంక్షన్‌లు లేదా రకాలను నిర్వచించగలము (ఉదా., T మరియు U):

function mergeObjects<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

సాధారణ పరిమితులు

కొన్నిసార్లు మేము జెనరిక్ ద్వారా ఆమోదించబడిన రకాలను పరిమితం చేయాలనుకుంటున్నాము. మేము పరిమితిని జోడించడానికి extends కీవర్డ్‌ని ఉపయోగించవచ్చు.

ఉదాహరణకు, మేము సాధారణ రకం ఎల్లప్పుడూ length ఆస్తిని కలిగి ఉండాలని కోరుకుంటే (తీగలు లేదా శ్రేణుల వంటివి):

interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): void {
  console.log(arg.length); // Safe! We know arg has 'length'
}

logLength('Hello'); // Valid
logLength([1, 2, 3]); // Valid
// logLength(42); // Error: number does not have a length property!

మీరే ప్రయత్నించండి

వ్యాయామం 1: సాధారణ గుర్తింపు ఫంక్షన్

వ్యాయామం 2: జెనరిక్ బాక్స్ రేపర్

వ్యాయామం 3: సాధారణ నిర్బంధం

వ్యాయామం 4: సాధారణ జంట