टाइपस्क्रिप्ट अॅडव्हान्स्ड टाइप्स: टेम्पलेट लिटरल्स आणि कंडिशनल टाइप्समध्ये प्राविण्य

आंतरराष्ट्रीय उदाहरण: विविध तारीख स्वरूप हाताळणे

जगातील विविध प्रदेश वेगवेगळे तारीख स्वरूप वापरतात. तुम्ही या फरकांना हाताळण्यासाठी कंडिशनल टाइप्स वापरू शकता.

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("Invalid date format");
  }
}

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(`Processing event ${event}`);

    //खऱ्या इम्प्लिमेंटेशनमध्ये, पेलोड इव्हेंट टाइपवर आधारित असेल.
    return { type: event, payload: {} } as ExtractEventPayload;
}

//लक्षात घ्या की रिटर्न टाइप्स खूप विशिष्ट आहेत:
const clickEvent = processEvent("onClick");  //  { type: "onClick"; payload: any; }
const mouseOverEvent = processEvent("onMouseOver"); //  { type: "onMouseOver"; payload: any; }

//जर तुम्ही इतर स्ट्रिंग्स वापरल्या, तर तुम्हाला never मिळेल:
// const someOtherEvent = processEvent("someOtherEvent"); // टाइप `never` आहे

सर्वोत्तम पद्धती आणि विचार

• सोपे ठेवा: शक्तिशाली असले तरी, हे प्रगत टाइप्स लवकरच क्लिष्ट होऊ शकतात. स्पष्टता आणि सुलभतेसाठी प्रयत्न करा.
• सखोल चाचणी करा: सर्वसमावेशक युनिट टेस्ट लिहून तुमच्या टाइप डेफिनिशन्स अपेक्षेप्रमाणे वागतात याची खात्री करा.
• तुमचा कोड डॉक्युमेंट करा: कोडची वाचनीयता सुधारण्यासाठी तुमच्या प्रगत टाइप्सचा उद्देश आणि वर्तन स्पष्टपणे डॉक्युमेंट करा.
• कार्यक्षमतेचा विचार करा: प्रगत टाइप्सच्या अतिवापरामुळे कंपाइलेशन वेळेवर परिणाम होऊ शकतो. तुमच्या कोडचे प्रोफाइल करा आणि आवश्यकतेनुसार ऑप्टिमाइझ करा.