టైప్‌స్క్రిప్ట్ యొక్క మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌లో నైపుణ్యం

జావాస్క్రిప్ట్ యొక్క సూపర్‌సెట్ అయిన టైప్‌స్క్రిప్ట్, పటిష్టమైన మరియు నిర్వహించగల అప్లికేషన్‌లను రూపొందించడానికి శక్తివంతమైన ఫీచర్‌లను అందిస్తుంది. ఈ ఫీచర్లలో, మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్ అధునాతన టైప్ మానిప్యులేషన్ కోసం అవసరమైన సాధనాలుగా నిలుస్తాయి. ఈ గైడ్ ఈ భావనల యొక్క సమగ్ర అవలోకనాన్ని అందిస్తుంది, వాటి సింటాక్స్, ఆచరణాత్మక అప్లికేషన్‌లు మరియు అధునాతన వినియోగ కేసులను అన్వేషిస్తుంది. మీరు అనుభవజ్ఞుడైన టైప్‌స్క్రిప్ట్ డెవలపర్ అయినా లేదా మీ ప్రయాణాన్ని ఇప్పుడే ప్రారంభిస్తున్నా, ఈ ఫీచర్‌లను సమర్థవంతంగా ఉపయోగించుకోవడానికి ఈ కథనం మీకు జ్ఞానాన్ని అందిస్తుంది.

మ్యాప్డ్ టైప్స్ అంటే ఏమిటి?

మ్యాప్డ్ టైప్స్ ఇప్పటికే ఉన్న టైప్స్‌ను మార్చడం ద్వారా కొత్త టైప్స్‌ను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి. అవి ఇప్పటికే ఉన్న టైప్ యొక్క ప్రాపర్టీలపై ఇటరేట్ చేసి, ప్రతి ప్రాపర్టీకి ఒక మార్పును వర్తింపజేస్తాయి. అన్ని ప్రాపర్టీలను ఆప్షనల్ లేదా రీడ్-ఓన్లీగా చేయడం వంటి ఇప్పటికే ఉన్న టైప్స్ యొక్క వైవిధ్యాలను సృష్టించడానికి ఇది ప్రత్యేకంగా ఉపయోగపడుతుంది.

ప్రాథమిక సింటాక్స్

ఒక మ్యాప్డ్ టైప్ కోసం సింటాక్స్ ఈ క్రింది విధంగా ఉంటుంది:

type NewType<T> = {
  [K in keyof T]: Transformation;
};

• T: మీరు మ్యాప్ చేయాలనుకుంటున్న ఇన్‌పుట్ టైప్.
• K in keyof T: ఇన్‌పుట్ టైప్ Tలోని ప్రతి కీపై ఇటరేట్ చేస్తుంది. keyof T అనేది Tలోని అన్ని ప్రాపర్టీ పేర్ల యూనియన్‌ను సృష్టిస్తుంది, మరియు ఇటరేషన్ సమయంలో K ప్రతి ఒక్క కీని సూచిస్తుంది.
• Transformation: మీరు ప్రతి ప్రాపర్టీకి వర్తింపజేయాలనుకుంటున్న మార్పు. ఇది మోడిఫైయర్‌ను జోడించడం (readonly లేదా ? వంటివి), టైప్‌ను మార్చడం లేదా పూర్తిగా మరేదైనా కావచ్చు.

ఆచరణాత్మక ఉదాహరణలు

ప్రాపర్టీలను రీడ్-ఓన్లీగా చేయడం

మీకు యూజర్ ప్రొఫైల్‌ను సూచించే ఒక ఇంటర్‌ఫేస్ ఉందని అనుకుందాం:

interface UserProfile {
  name: string;
  age: number;
  email: string;
}

మీరు అన్ని ప్రాపర్టీలు రీడ్-ఓన్లీగా ఉండే కొత్త టైప్‌ను సృష్టించవచ్చు:

type ReadOnlyUserProfile = {
  readonly [K in keyof UserProfile]: UserProfile[K];
};

ఇప్పుడు, ReadOnlyUserProfile అనేది UserProfile వలె అదే ప్రాపర్టీలను కలిగి ఉంటుంది, కానీ అవన్నీ రీడ్-ఓన్లీగా ఉంటాయి.

ప్రాపర్టీలను ఐచ్ఛికంగా చేయడం

అదేవిధంగా, మీరు అన్ని ప్రాపర్టీలను ఐచ్ఛికంగా చేయవచ్చు:

type OptionalUserProfile = {
  [K in keyof UserProfile]?: UserProfile[K];
};

OptionalUserProfile అనేది UserProfile యొక్క అన్ని ప్రాపర్టీలను కలిగి ఉంటుంది, కానీ ప్రతి ప్రాపర్టీ ఐచ్ఛికంగా ఉంటుంది.

ప్రాపర్టీ టైప్స్‌ను మార్చడం

మీరు ప్రతి ప్రాపర్టీ యొక్క టైప్‌ను కూడా మార్చవచ్చు. ఉదాహరణకు, మీరు అన్ని ప్రాపర్టీలను స్ట్రింగ్స్‌గా మార్చవచ్చు:

type StringifiedUserProfile = {
  [K in keyof UserProfile]: string;
};

ఈ సందర్భంలో, StringifiedUserProfileలోని అన్ని ప్రాపర్టీలు string టైప్ యొక్కవిగా ఉంటాయి.

కండిషనల్ టైప్స్ అంటే ఏమిటి?

కండిషనల్ టైప్స్ ఒక షరతుపై ఆధారపడి ఉండే టైప్స్‌ను నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తాయి. ఒక టైప్ ఒక నిర్దిష్ట పరిమితిని సంతృప్తి చేస్తుందా లేదా అనే దాని ఆధారంగా టైప్ సంబంధాలను వ్యక్తీకరించడానికి అవి ఒక మార్గాన్ని అందిస్తాయి. ఇది జావాస్క్రిప్ట్‌లోని టెర్నరీ ఆపరేటర్ లాంటిదే, కానీ టైప్స్ కోసం.

ప్రాథమిక సింటాక్స్

ఒక కండిషనల్ టైప్ కోసం సింటాక్స్ ఈ క్రింది విధంగా ఉంటుంది:

T extends U ? X : Y

• T: తనిఖీ చేయబడుతున్న టైప్.
• U: T ద్వారా విస్తరించబడుతున్న టైప్ (షరతు).
• X: T అనేది Uను విస్తరిస్తే తిరిగి ఇవ్వవలసిన టైప్ (షరతు నిజం).
• Y: T అనేది Uను విస్తరించకపోతే తిరిగి ఇవ్వవలసిన టైప్ (షరతు తప్పు).

ఆచరణాత్మక ఉదాహరణలు

ఒక టైప్ స్ట్రింగ్ కాదా అని నిర్ధారించడం

ఇన్‌పుట్ టైప్ స్ట్రింగ్ అయితే stringను, లేకపోతే numberను తిరిగి ఇచ్చే ఒక టైప్‌ను సృష్టిద్దాం:

type StringOrNumber<T> = T extends string ? string : number;

type Result1 = StringOrNumber<string>;  // స్ట్రింగ్
type Result2 = StringOrNumber<number>;  // నంబర్
type Result3 = StringOrNumber<boolean>; // నంబర్

యూనియన్ నుండి టైప్‌ను సంగ్రహించడం

యూనియన్ టైప్ నుండి ఒక నిర్దిష్ట టైప్‌ను సంగ్రహించడానికి మీరు కండిషనల్ టైప్స్‌ను ఉపయోగించవచ్చు. ఉదాహరణకు, నాన్-నల్లబుల్ టైప్స్‌ను సంగ్రహించడానికి:

type NonNullable<T> = T extends null | undefined ? never : T;

type Result4 = NonNullable<string | null | undefined>; // స్ట్రింగ్

ఇక్కడ, T అనేది null లేదా undefined అయితే, టైప్ never అవుతుంది, ఇది టైప్‌స్క్రిప్ట్ యొక్క యూనియన్ టైప్ సరళీకరణ ద్వారా ఫిల్టర్ చేయబడుతుంది.

టైప్స్‌ను ఊహించడం (Inferring)

infer కీవర్డ్‌ను ఉపయోగించి టైప్స్‌ను ఊహించడానికి కూడా కండిషనల్ టైప్స్‌ను ఉపయోగించవచ్చు. ఇది మరింత సంక్లిష్టమైన టైప్ నిర్మాణం నుండి ఒక టైప్‌ను సంగ్రహించడానికి మిమ్మల్ని అనుమతిస్తుంది.

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

function myFunction(x: number): string {
  return x.toString();
}

type Result5 = ReturnType<typeof myFunction>; // స్ట్రింగ్

ఈ ఉదాహరణలో, ReturnType ఒక ఫంక్షన్ యొక్క రిటర్న్ టైప్‌ను సంగ్రహిస్తుంది. ఇది T ఏదైనా ఆర్గ్యుమెంట్లను తీసుకుని, R టైప్‌ను తిరిగి ఇచ్చే ఫంక్షన్ కాదా అని తనిఖీ చేస్తుంది. అలా అయితే, అది Rను తిరిగి ఇస్తుంది; లేకపోతే, అది anyను తిరిగి ఇస్తుంది.

మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌ను కలపడం

మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్ యొక్క నిజమైన శక్తి వాటిని కలపడం ద్వారా వస్తుంది. ఇది అత్యంత ఫ్లెక్సిబుల్ మరియు వ్యక్తీకరణాత్మక టైప్ మార్పులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఉదాహరణ: డీప్ రీడ్ఓన్లీ

ఒక సాధారణ వినియోగ కేసు ఏమిటంటే, ఒక ఆబ్జెక్ట్ యొక్క అన్ని ప్రాపర్టీలను, నెస్ట్ చేయబడిన ప్రాపర్టీలతో సహా, రీడ్-ఓన్లీగా చేసే ఒక టైప్‌ను సృష్టించడం. దీనిని పునరావృత కండిషనల్ టైప్ ఉపయోగించి సాధించవచ్చు.

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
};

interface Company {
  name: string;
  address: {
    street: string;
    city: string;
  };
}

type ReadonlyCompany = DeepReadonly<Company>;

ఇక్కడ, DeepReadonly అన్ని ప్రాపర్టీలకు మరియు వాటి నెస్ట్ చేయబడిన ప్రాపర్టీలకు పునరావృతంగా readonly మోడిఫైయర్‌ను వర్తింపజేస్తుంది. ఒక ప్రాపర్టీ ఆబ్జెక్ట్ అయితే, అది ఆ ఆబ్జెక్ట్‌పై DeepReadonlyను పునరావృతంగా పిలుస్తుంది. లేకపోతే, అది కేవలం ప్రాపర్టీకి readonly మోడిఫైయర్‌ను వర్తింపజేస్తుంది.

ఉదాహరణ: టైప్ ద్వారా ప్రాపర్టీలను ఫిల్టర్ చేయడం

మీరు ఒక నిర్దిష్ట టైప్ యొక్క ప్రాపర్టీలను మాత్రమే కలిగి ఉండే ఒక టైప్‌ను సృష్టించాలనుకుంటున్నారని అనుకుందాం. దీనిని సాధించడానికి మీరు మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌ను కలపవచ్చు.

type FilterByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

interface Person {
  name: string;
  age: number;
  isEmployed: boolean;
}

type StringProperties = FilterByType<Person, string>; // { name: string; }

type NonStringProperties = Omit<Person, keyof StringProperties>;

ఈ ఉదాహరణలో, FilterByType T యొక్క ప్రాపర్టీలపై ఇటరేట్ చేసి, ప్రతి ప్రాపర్టీ యొక్క టైప్ Uను విస్తరిస్తుందో లేదో తనిఖీ చేస్తుంది. అలా అయితే, అది ఫలిత టైప్‌లో ప్రాపర్టీని చేర్చుతుంది; లేకపోతే, కీని neverకు మ్యాప్ చేయడం ద్వారా దాన్ని మినహాయిస్తుంది. కీలను రీమ్యాప్ చేయడానికి "as" వాడకాన్ని గమనించండి. మేము అసలు ఇంటర్‌ఫేస్ నుండి స్ట్రింగ్ ప్రాపర్టీలను తొలగించడానికి `Omit` మరియు `keyof StringProperties`ను ఉపయోగిస్తాము.

అధునాతన వినియోగ కేసులు మరియు పద్ధతులు

ప్రాథమిక ఉదాహరణలకు మించి, మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌ను మరింత అధునాతన దృశ్యాలలో ఉపయోగించి అత్యంత అనుకూలీకరించదగిన మరియు టైప్-సేఫ్ అప్లికేషన్‌లను సృష్టించవచ్చు.

డిస్ట్రిబ్యూటివ్ కండిషనల్ టైప్స్

తనిఖీ చేయబడుతున్న టైప్ ఒక యూనియన్ టైప్ అయినప్పుడు కండిషనల్ టైప్స్ డిస్ట్రిబ్యూటివ్ (విభజనీయ)గా ఉంటాయి. దీని అర్థం షరతు యూనియన్ యొక్క ప్రతి సభ్యునికి వ్యక్తిగతంగా వర్తింపజేయబడుతుంది, మరియు ఫలితాలు కొత్త యూనియన్ టైప్‌గా కలపబడతాయి.

type ToArray<T> = T extends any ? T[] : never;

type Result6 = ToArray<string | number>; // string[] | number[]

ఈ ఉదాహరణలో, ToArray యూనియన్ string | number యొక్క ప్రతి సభ్యునికి వ్యక్తిగతంగా వర్తింపజేయబడుతుంది, ఫలితంగా string[] | number[] వస్తుంది. షరతు డిస్ట్రిబ్యూటివ్ కాకపోతే, ఫలితం (string | number)[] అయ్యేది.

యుటిలిటీ టైప్స్‌ను ఉపయోగించడం

టైప్‌స్క్రిప్ట్ మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌ను ఉపయోగించుకునే అనేక అంతర్నిర్మిత యుటిలిటీ టైప్స్‌ను అందిస్తుంది. ఈ యుటిలిటీ టైప్స్‌ను మరింత సంక్లిష్టమైన టైప్ మార్పుల కోసం బిల్డింగ్ బ్లాక్స్‌గా ఉపయోగించవచ్చు.

• Partial<T>: T యొక్క అన్ని ప్రాపర్టీలను ఐచ్ఛికంగా చేస్తుంది.
• Required<T>: T యొక్క అన్ని ప్రాపర్టీలను అవసరమైనవిగా చేస్తుంది.
• Readonly<T>: T యొక్క అన్ని ప్రాపర్టీలను రీడ్-ఓన్లీగా చేస్తుంది.
• Pick<T, K>: T నుండి ప్రాపర్టీల సెట్ Kను ఎంచుకుంటుంది.
• Omit<T, K>: T నుండి ప్రాపర్టీల సెట్ Kను తొలగిస్తుంది.
• Record<K, T>: టైప్ T యొక్క ప్రాపర్టీల సెట్ Kతో ఒక టైప్‌ను నిర్మిస్తుంది.
• Exclude<T, U>: T నుండి Uకు కేటాయించదగిన అన్ని టైప్స్‌ను మినహాయిస్తుంది.
• Extract<T, U>: T నుండి Uకు కేటాయించదగిన అన్ని టైప్స్‌ను సంగ్రహిస్తుంది.
• NonNullable<T>: T నుండి null మరియు undefinedను మినహాయిస్తుంది.
• Parameters<T>: ఒక ఫంక్షన్ టైప్ T యొక్క పారామీటర్లను పొందుతుంది.
• ReturnType<T>: ఒక ఫంక్షన్ టైప్ T యొక్క రిటర్న్ టైప్‌ను పొందుతుంది.
• InstanceType<T>: ఒక కన్‌స్ట్రక్టర్ ఫంక్షన్ టైప్ T యొక్క ఇన్‌స్టాన్స్ టైప్‌ను పొందుతుంది.

ఈ యుటిలిటీ టైప్స్ సంక్లిష్టమైన టైప్ మానిప్యులేషన్‌లను సరళీకరించగల శక్తివంతమైన సాధనాలు. ఉదాహరణకు, మీరు కేవలం కొన్ని ప్రాపర్టీలను మాత్రమే ఐచ్ఛికంగా చేసే ఒక టైప్‌ను సృష్టించడానికి Pick మరియు Partialను కలపవచ్చు:

type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type OptionalDescriptionProduct = Optional<Product, "description">;

ఈ ఉదాహరణలో, OptionalDescriptionProduct Product యొక్క అన్ని ప్రాపర్టీలను కలిగి ఉంటుంది, కానీ description ప్రాపర్టీ ఐచ్ఛికంగా ఉంటుంది.

టెంప్లేట్ లిటరల్ టైప్స్‌ను ఉపయోగించడం

టెంప్లేట్ లిటరల్ టైప్స్ స్ట్రింగ్ లిటరల్స్ ఆధారంగా టైప్స్‌ను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి. డైనమిక్ మరియు వ్యక్తీకరణాత్మక టైప్ మార్పులను సృష్టించడానికి వాటిని మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్‌తో కలిపి ఉపయోగించవచ్చు. ఉదాహరణకు, మీరు అన్ని ప్రాపర్టీ పేర్లకు ఒక నిర్దిష్ట స్ట్రింగ్‌తో ఉపసర్గను జోడించే ఒక టైప్‌ను సృష్టించవచ్చు:

type Prefix<T, P extends string> = {
  [K in keyof T as `${P}${string & K}`]: T[K];
};

interface Settings {
  apiUrl: string;
  timeout: number;
}

type PrefixedSettings = Prefix<Settings, "data_">;

ఈ ఉదాహరణలో, PrefixedSettings data_apiUrl మరియు data_timeout అనే ప్రాపర్టీలను కలిగి ఉంటుంది.

ఉత్తమ పద్ధతులు మరియు పరిగణనలు

• సరళంగా ఉంచండి: మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్ శక్తివంతమైనవి అయినప్పటికీ, అవి మీ కోడ్‌ను మరింత సంక్లిష్టంగా మార్చగలవు. మీ టైప్ మార్పులను సాధ్యమైనంత సరళంగా ఉంచడానికి ప్రయత్నించండి.
• యుటిలిటీ టైప్స్‌ను ఉపయోగించండి: సాధ్యమైనప్పుడల్లా టైప్‌స్క్రిప్ట్ యొక్క అంతర్నిర్మిత యుటిలిటీ టైప్స్‌ను ఉపయోగించుకోండి. అవి బాగా పరీక్షించబడ్డాయి మరియు మీ కోడ్‌ను సరళీకరించగలవు.
• మీ టైప్స్‌ను డాక్యుమెంట్ చేయండి: మీ టైప్ మార్పులను స్పష్టంగా డాక్యుమెంట్ చేయండి, ముఖ్యంగా అవి సంక్లిష్టంగా ఉంటే. ఇది ఇతర డెవలపర్‌లకు మీ కోడ్‌ను అర్థం చేసుకోవడంలో సహాయపడుతుంది.
• మీ టైప్స్‌ను పరీక్షించండి: మీ టైప్ మార్పులు ఆశించిన విధంగా పనిచేస్తున్నాయని నిర్ధారించుకోవడానికి టైప్‌స్క్రిప్ట్ యొక్క టైప్ తనిఖీని ఉపయోగించండి. మీ టైప్స్ యొక్క ప్రవర్తనను ధృవీకరించడానికి మీరు యూనిట్ పరీక్షలను వ్రాయవచ్చు.
• పనితీరును పరిగణించండి: సంక్లిష్టమైన టైప్ మార్పులు మీ టైప్‌స్క్రిప్ట్ కంపైలర్ పనితీరును ప్రభావితం చేయగలవు. మీ టైప్స్ యొక్క సంక్లిష్టత పట్ల శ్రద్ధ వహించండి మరియు అనవసరమైన గణనలను నివారించండి.

ముగింపు

మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్ టైప్‌స్క్రిప్ట్‌లో శక్తివంతమైన ఫీచర్లు, ఇవి అత్యంత ఫ్లెక్సిబుల్ మరియు వ్యక్తీకరణాత్మక టైప్ మార్పులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తాయి. ఈ భావనలలో నైపుణ్యం సాధించడం ద్వారా, మీరు మీ టైప్‌స్క్రిప్ట్ అప్లికేషన్‌ల యొక్క టైప్ భద్రత, నిర్వహణ సామర్థ్యం మరియు మొత్తం నాణ్యతను మెరుగుపరచవచ్చు. ప్రాపర్టీలను ఐచ్ఛికంగా లేదా రీడ్-ఓన్లీగా చేయడం వంటి సాధారణ మార్పుల నుండి సంక్లిష్టమైన పునరావృత మార్పులు మరియు షరతులతో కూడిన లాజిక్ వరకు, ఈ ఫీచర్లు పటిష్టమైన మరియు స్కేలబుల్ అప్లికేషన్‌లను రూపొందించడానికి అవసరమైన సాధనాలను అందిస్తాయి. వాటి పూర్తి సామర్థ్యాన్ని అన్‌లాక్ చేయడానికి మరియు మరింత నిష్ణాతుడైన టైప్‌స్క్రిప్ట్ డెవలపర్‌గా మారడానికి ఈ ఫీచర్‌లను అన్వేషించడం మరియు ప్రయోగాలు చేయడం కొనసాగించండి.

మీరు మీ టైప్‌స్క్రిప్ట్ ప్రయాణాన్ని కొనసాగిస్తున్నప్పుడు, అధికారిక టైప్‌స్క్రిప్ట్ డాక్యుమెంటేషన్, ఆన్‌లైన్ కమ్యూనిటీలు మరియు ఓపెన్-సోర్స్ ప్రాజెక్ట్‌లతో సహా అందుబాటులో ఉన్న వనరుల సంపదను ఉపయోగించుకోవాలని గుర్తుంచుకోండి. మ్యాప్డ్ టైప్స్ మరియు కండిషనల్ టైప్స్ యొక్క శక్తిని స్వీకరించండి, మరియు మీరు అత్యంత సవాలుగా ఉండే టైప్-సంబంధిత సమస్యలను కూడా పరిష్కరించడానికి సుసన్నద్ధులవుతారు.