టైప్‌స్క్రిప్ట్ అడ్వాన్స్‌డ్ టైప్స్: టెంప్లేట్ లిటరల్ మరియు కండిషనల్ టైప్స్‌లో నైపుణ్యం సాధించడం

అంతర్జాతీయ ఉదాహరణ: వివిధ తేదీ ఫార్మాట్‌లను నిర్వహించడం

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

type DateFormat = "YYYY-MM-DD" | "MM/DD/YYYY" | "DD.MM.YYYY";

type ParseDate = T extends "YYYY-MM-DD"
  ? { year: number; month: number; day: number; format: "YYYY-MM-DD" }
  : T extends "MM/DD/YYYY"
  ? { month: number; day: number; year: number; format: "MM/DD/YYYY" }
  : T extends "DD.MM.YYYY"
  ? { day: number; month: number; year: number; format: "DD.MM.YYYY" }
  : never;


function parseDate(dateString: string, format: T): ParseDate {
  // (అమలు వివిధ తేదీ ఫార్మాట్‌లను నిర్వహిస్తుంది)
  if (format === "YYYY-MM-DD") {
    const [year, month, day] = dateString.split("-").map(Number);
    return { year, month, day, format } as ParseDate;
  } else if (format === "MM/DD/YYYY") {
    const [month, day, year] = dateString.split("/").map(Number);
    return { month, day, year, format } as ParseDate;
  } else if (format === "DD.MM.YYYY") {
    const [day, month, year] = dateString.split(".").map(Number);
    return { day, month, year, format } as ParseDate;
  } else {
    throw new Error("చెల్లని తేదీ ఫార్మాట్");
  }
}

const parsedDateISO = parseDate("2023-10-27", "YYYY-MM-DD"); // టైప్: { year: number; month: number; day: number; format: "YYYY-MM-DD"; }
const parsedDateUS = parseDate("10/27/2023", "MM/DD/YYYY"); // టైప్: { month: number; day: number; year: number; format: "MM/DD/YYYY"; }
const parsedDateEU = parseDate("27.10.2023", "DD.MM.YYYY"); // టైప్: { day: number; month: number; year: number; format: "DD.MM.YYYY"; }


console.log(parsedDateISO.year); // సంవత్సరం ఉంటుందని తెలిసి దాన్ని యాక్సెస్ చేయండి

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

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

మీరు టెంప్లేట్ లిటరల్ టైప్స్ మరియు కండిషనల్ టైప్స్‌ను కలిపినప్పుడు అసలైన శక్తి వస్తుంది. ఇది చాలా శక్తివంతమైన టైప్ మానిప్యులేషన్‌లను అనుమతిస్తుంది.

type EventName = `on${Capitalize}`;

type ExtractEventPayload = T extends EventName
  ? { type: T; payload: any }  // ప్రదర్శన కోసం సులభతరం చేయబడింది
  : never;


type ClickEvent = EventName<"click">;  // "onClick"
type MouseOverEvent = EventName<"mouseOver">;  // "onMouseOver"


//ఒక టైప్‌ను తీసుకునే ఉదాహరణ ఫంక్షన్
function processEvent(event: T): ExtractEventPayload {
    //నిజమైన అమలులో, మనం వాస్తవానికి ఈవెంట్‌ను డిస్పాచ్ చేస్తాము.
    console.log(`ఈవెంట్ ప్రాసెస్ అవుతోంది ${event}`);

    //నిజమైన అమలులో, పేలోడ్ ఈవెంట్ టైప్ ఆధారంగా ఉంటుంది.
    return { type: event, payload: {} } as ExtractEventPayload;
}

//రిటర్న్ టైప్స్ చాలా నిర్దిష్టంగా ఉన్నాయని గమనించండి:
const clickEvent = processEvent("onClick");  //  { type: "onClick"; payload: any; }
const mouseOverEvent = processEvent("onMouseOver"); //  { type: "onMouseOver"; payload: any; }

//మీరు ఇతర స్ట్రింగ్‌లను ఉపయోగిస్తే, మీకు నెవర్ వస్తుంది:
// const someOtherEvent = processEvent("someOtherEvent"); // టైప్ `never`

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

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