टाइपस्क्रिप्ट टेम्पलेट लिटरल पार्सर कॉम्बिनेटर्स: जटिल स्ट्रिंग प्रकार का विश्लेषण

टाइपस्क्रिप्ट के टेम्पलेट लिटरल्स, कंडीशनल टाइप्स और टाइप इनफेरेंस के साथ मिलकर, कंपाइल-टाइम पर स्ट्रिंग टाइप्स में हेरफेर और विश्लेषण करने के लिए शक्तिशाली उपकरण प्रदान करते हैं। यह ब्लॉग पोस्ट बताता है कि इन सुविधाओं का उपयोग करके पार्सर कॉम्बिनेटर्स कैसे बनाएं ताकि जटिल स्ट्रिंग संरचनाओं को संभाला जा सके, जिससे आपके टाइपस्क्रिप्ट प्रोजेक्ट्स में मजबूत टाइप सत्यापन और परिवर्तन सक्षम हो सके।

टेम्पलेट लिटरल टाइप्स का परिचय

टेम्पलेट लिटरल टाइप्स आपको ऐसे स्ट्रिंग टाइप्स को परिभाषित करने की अनुमति देते हैं जिनमें एम्बेडेड एक्सप्रेशंस होते हैं। ये एक्सप्रेशंस कंपाइल-टाइम पर मूल्यांकित होते हैं, जो उन्हें टाइप-सेफ स्ट्रिंग मैनिपुलेशन यूटिलिटीज बनाने के लिए अविश्वसनीय रूप से उपयोगी बनाता है।

उदाहरण के लिए:

            type Greeting<T extends string> = `Hello, ${T}!`;

type MyGreeting = Greeting<"World">; // Type is "Hello, World!"

            

              
                Copy
              
            
          

यह सरल उदाहरण मूल सिंटैक्स को दर्शाता है। असली शक्ति टेम्पलेट लिटरल्स को कंडीशनल टाइप्स और इनफेरेंस के साथ जोड़ने में है।

कंडीशनल टाइप्स और इनफेरेंस

टाइपस्क्रिप्ट में कंडीशनल टाइप्स आपको ऐसे टाइप्स को परिभाषित करने की अनुमति देते हैं जो एक शर्त पर निर्भर करते हैं। इसका सिंटैक्स टर्नरी ऑपरेटर के समान है: `T extends U ? X : Y`। यदि `T` को `U` में असाइन किया जा सकता है, तो टाइप `X` है; अन्यथा, यह `Y` है।

टाइप इनफेरेंस, `infer` कीवर्ड का उपयोग करके, आपको एक टाइप के विशिष्ट हिस्सों को निकालने की अनुमति देता है। यह विशेष रूप से टेम्पलेट लिटरल टाइप्स के साथ काम करते समय उपयोगी होता है।

इस उदाहरण पर विचार करें:

            type GetParameterType<T extends string> = T extends `(param: ${infer P}) => void` ? P : never;

type MyParameterType = GetParameterType<'(param: number) => void'>; // Type is number

            

              
                Copy
              
            
          

यहाँ, हम `infer P` का उपयोग एक स्ट्रिंग के रूप में दर्शाए गए फ़ंक्शन टाइप से पैरामीटर के टाइप को निकालने के लिए करते हैं।

पार्सर कॉम्बिनेटर्स: स्ट्रिंग विश्लेषण के लिए बिल्डिंग ब्लॉक्स

पार्सर कॉम्बिनेटर्स पार्सर बनाने के लिए एक फंक्शनल प्रोग्रामिंग तकनीक है। एक अकेला, मोनोलिथिक पार्सर लिखने के बजाय, आप छोटे, पुन: प्रयोज्य पार्सर बनाते हैं और उन्हें अधिक जटिल ग्रामर को संभालने के लिए जोड़ते हैं। टाइपस्क्रिप्ट टाइप सिस्टम के संदर्भ में, ये "पार्सर" स्ट्रिंग टाइप्स पर काम करते हैं।

हम कुछ बुनियादी पार्सर कॉम्बिनेटर्स को परिभाषित करेंगे जो अधिक जटिल पार्सर्स के लिए बिल्डिंग ब्लॉक्स के रूप में काम करेंगे। ये उदाहरण परिभाषित पैटर्न के आधार पर स्ट्रिंग्स के विशिष्ट हिस्सों को निकालने पर ध्यान केंद्रित करते हैं।

बुनियादी कॉम्बिनेटर्स

`StartsWith<T, Prefix>`

जांचता है कि क्या स्ट्रिंग टाइप `T` दिए गए प्रीफिक्स `Prefix` से शुरू होता है। यदि ऐसा होता है, तो यह स्ट्रिंग का शेष भाग लौटाता है; अन्यथा, यह `never` लौटाता है।

            type StartsWith<T extends string, Prefix extends string> = T extends `${Prefix}${infer Rest}` ? Rest : never;

type Remaining = StartsWith<"Hello, World!", "Hello, ">; // Type is "World!"

type Never = StartsWith<"Hello, World!", "Goodbye, ">; // Type is never

            

              
                Copy
              
            
          

`EndsWith<T, Suffix>`

जांचता है कि क्या स्ट्रिंग टाइप `T` दिए गए सफिक्स `Suffix` के साथ समाप्त होता है। यदि ऐसा होता है, तो यह सफिक्स से पहले स्ट्रिंग का हिस्सा लौटाता है; अन्यथा, यह `never` लौटाता है।

            type EndsWith<T extends string, Suffix extends string> = T extends `${infer Rest}${Suffix}` ? Rest : never;

type Before = EndsWith<"Hello, World!", "!">; // Type is "Hello, World"

type Never = EndsWith<"Hello, World!", ".">; // Type is never

            

              
                Copy
              
            
          

`Between<T, Start, End>`

`Start` और `End` डेलीमीटर के बीच स्ट्रिंग के हिस्से को निकालता है। यदि डेलीमीटर सही क्रम में नहीं मिलते हैं तो `never` लौटाता है।

            type Between<T extends string, Start extends string, End extends string> = StartsWith<T, Start> extends never ? never : EndsWith<StartsWith<T, Start>, End>;

type Content = Between<"<div>Content</div>", "<div>", "</div>">; // Type is "Content"

type Never = Between<"<div>Content</span>", "<div>", "</div>">; // Type is never

            

              
                Copy
              
            
          

कॉम्बिनेटर्स को जोड़ना

पार्सर कॉम्बिनेटर्स की असली शक्ति उनकी संयुक्त होने की क्षमता से आती है। चलिए एक अधिक जटिल पार्सर बनाते हैं जो CSS स्टाइल प्रॉपर्टी से मान निकालता है।

`ExtractCSSValue<T, Property>`

यह पार्सर एक CSS स्ट्रिंग `T` और एक प्रॉपर्टी नाम `Property` लेता है और संबंधित मान निकालता है। यह मानता है कि CSS स्ट्रिंग `property: value;` प्रारूप में है।

            type ExtractCSSValue<T extends string, Property extends string> = Between<T, `${Property}: `, ";">;

type ColorValue = ExtractCSSValue<"color: red; font-size: 16px;", "color">; // Type is "red"

type FontSizeValue = ExtractCSSValue<"color: blue; font-size: 12px;", "font-size">; // Type is "12px"

            

              
                Copy
              
            
          

यह उदाहरण दिखाता है कि `Between` का उपयोग `StartsWith` और `EndsWith` को अंतर्निहित रूप से संयोजित करने के लिए कैसे किया जाता है। हम निर्दिष्ट प्रॉपर्टी से जुड़े मान को निकालने के लिए CSS स्ट्रिंग को प्रभावी ढंग से पार्स कर रहे हैं। इसे नेस्टेड नियमों और वेंडर प्रीफिक्स के साथ अधिक जटिल CSS संरचनाओं को संभालने के लिए बढ़ाया जा सकता है।

उन्नत उदाहरण: स्ट्रिंग प्रकारों का सत्यापन और परिवर्तन

सरल निष्कर्षण से परे, पार्सर कॉम्बिनेटर्स का उपयोग स्ट्रिंग प्रकारों के सत्यापन और परिवर्तन के लिए किया जा सकता है। चलिए कुछ उन्नत परिदृश्यों का पता लगाते हैं।

ईमेल पतों का सत्यापन

टाइपस्क्रिप्ट प्रकारों में रेगुलर एक्सप्रेशन का उपयोग करके ईमेल पतों को मान्य करना चुनौतीपूर्ण है, लेकिन हम पार्सर कॉम्बिनेटर्स का उपयोग करके एक सरलीकृत सत्यापन बना सकते हैं। ध्यान दें कि यह एक पूर्ण ईमेल सत्यापन समाधान नहीं है, लेकिन सिद्धांत को प्रदर्शित करता है।

            type IsEmail<T extends string> = T extends `${infer Username}@${infer Domain}.${infer TLD}` ? (
  Username extends '' ? never : (
    Domain extends '' ? never : (
      TLD extends '' ? never : T
    )
  )
) : never;

type ValidEmail = IsEmail<"test@example.com">; // Type is "test@example.com"

type InvalidEmail = IsEmail<"test@example">; // Type is never

type AnotherInvalidEmail = IsEmail<"@example.com">; // Type is never

            

              
                Copy
              
            
          

यह `IsEmail` प्रकार `@` और `.` की उपस्थिति की जांच करता है और यह सुनिश्चित करता है कि उपयोगकर्ता नाम, डोमेन, और टॉप-लेवल डोमेन (TLD) खाली न हों। यह मान्य होने पर मूल ईमेल स्ट्रिंग लौटाता है या अमान्य होने पर `never` लौटाता है। एक अधिक मजबूत समाधान में ईमेल पते के प्रत्येक भाग में अनुमत वर्णों पर अधिक जटिल जांच शामिल हो सकती है, जिसमें मान्य वर्णों का प्रतिनिधित्व करने के लिए लुकअप प्रकारों का उपयोग किया जा सकता है।

स्ट्रिंग प्रकारों को बदलना: कैमल केस रूपांतरण

स्ट्रिंग्स को कैमल केस में बदलना एक आम काम है। हम इसे पार्सर कॉम्बिनेटर्स और रिकर्सिव टाइप डेफिनिशन का उपयोग करके प्राप्त कर सकते हैं। इसके लिए अधिक जटिल दृष्टिकोण की आवश्यकता है।

            type CamelCase<T extends string> = T extends `${infer FirstWord}_${infer SecondWord}${infer Rest}`
  ? `${FirstWord}${Capitalize<SecondWord>}${CamelCase<Rest>}`
  : T;

type Capitalize<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${Rest}` : S;

type MyCamelCase = CamelCase<"my_string_to_convert">; // Type is "myStringToConvert"

            

              
                Copy
              
            
          

यहाँ एक विवरण है:

• `CamelCase<T>`: यह मुख्य प्रकार है जो एक स्ट्रिंग को पुनरावर्ती रूप से कैमल केस में परिवर्तित करता है। यह जांचता है कि स्ट्रिंग में एक अंडरस्कोर (`_`) है या नहीं। यदि है, तो यह अगले शब्द को कैपिटलाइज़ करता है और स्ट्रिंग के शेष भाग पर `CamelCase` को पुनरावर्ती रूप से कॉल करता है।
• `Capitalize<S>`: यह हेल्पर प्रकार एक स्ट्रिंग के पहले अक्षर को कैपिटलाइज़ करता है। यह पहले वर्ण को अपरकेस में बदलने के लिए `Uppercase` का उपयोग करता है।

यह उदाहरण टाइपस्क्रिप्ट में रिकर्सिव टाइप डेफिनिशन की शक्ति को प्रदर्शित करता है। यह हमें कंपाइल-टाइम पर जटिल स्ट्रिंग परिवर्तन करने की अनुमति देता है।

CSV (कॉमा सेपरेटेड वैल्यूज) पार्स करना

CSV डेटा पार्स करना एक अधिक जटिल वास्तविक-दुनिया का परिदृश्य है। चलिए एक प्रकार बनाते हैं जो CSV स्ट्रिंग से हेडर निकालता है।

            type CSVHeaders<T extends string> = T extends `${infer Headers}\n${string}` ? Split<Headers, ','> : never;

type Split<T extends string, Separator extends string> = T extends `${infer Head}${Separator}${infer Tail}`
  ? [Head, ...Split<Tail, Separator>]
  : [T];

type MyCSVHeaders = CSVHeaders<"header1,header2,header3\nvalue1,value2,value3">; // Type is ["header1", "header2", "header3"]

            

              
                Copy
              
            
          

यह उदाहरण एक `Split` हेल्पर प्रकार का उपयोग करता है जो कॉमा सेपरेटर के आधार पर स्ट्रिंग को पुनरावर्ती रूप से विभाजित करता है। `CSVHeaders` प्रकार पहली पंक्ति (हेडर) को निकालता है और फिर हेडर स्ट्रिंग्स का एक टपल बनाने के लिए `Split` का उपयोग करता है। इसे पूरे CSV संरचना को पार्स करने और डेटा का एक प्रकार प्रतिनिधित्व बनाने के लिए बढ़ाया जा सकता है।

व्यावहारिक अनुप्रयोग

इन तकनीकों के टाइपस्क्रिप्ट विकास में विभिन्न व्यावहारिक अनुप्रयोग हैं:

• कॉन्फ़िगरेशन पार्सिंग: कॉन्फ़िगरेशन फ़ाइलों (जैसे, `.env` फ़ाइलें) से मानों को मान्य करना और निकालना। आप यह सुनिश्चित कर सकते हैं कि एप्लिकेशन शुरू होने से पहले विशिष्ट पर्यावरण चर मौजूद हैं और सही प्रारूप में हैं। API कुंजियों, डेटाबेस कनेक्शन स्ट्रिंग्स, या फ़ीचर फ़्लैग कॉन्फ़िगरेशन को मान्य करने की कल्पना करें।
• API अनुरोध/प्रतिक्रिया सत्यापन: ऐसे प्रकारों को परिभाषित करना जो API अनुरोधों और प्रतिक्रियाओं की संरचना का प्रतिनिधित्व करते हैं, बाहरी सेवाओं के साथ बातचीत करते समय प्रकार सुरक्षा सुनिश्चित करते हैं। आप API द्वारा लौटाए गए दिनांक, मुद्राओं, या अन्य विशिष्ट डेटा प्रकारों के प्रारूप को मान्य कर सकते हैं। यह REST API के साथ काम करते समय विशेष रूप से उपयोगी है।
• स्ट्रिंग-आधारित DSLs (डोमेन-विशिष्ट भाषाएं): विशिष्ट कार्यों के लिए टाइप-सेफ DSL बनाना, जैसे स्टाइलिंग नियम या डेटा सत्यापन स्कीमा को परिभाषित करना। यह कोड पठनीयता और रखरखाव में सुधार कर सकता है।
• कोड जनरेशन: स्ट्रिंग टेम्पलेट्स के आधार पर कोड उत्पन्न करना, यह सुनिश्चित करना कि उत्पन्न कोड वाक्यात्मक रूप से सही है। यह आमतौर पर टूलिंग और बिल्ड प्रक्रियाओं में उपयोग किया जाता है।
• डेटा परिवर्तन: डेटा को विभिन्न प्रारूपों के बीच परिवर्तित करना (जैसे, कैमल केस से स्नेक केस, JSON से XML)।

एक वैश्वीकृत ई-कॉमर्स एप्लिकेशन पर विचार करें। आप उपयोगकर्ता के क्षेत्र के आधार पर मुद्रा कोड को मान्य और प्रारूपित करने के लिए टेम्पलेट लिटरल प्रकारों का उपयोग कर सकते हैं। उदाहरण के लिए:

            type CurrencyCode = "USD" | "EUR" | "JPY" | "GBP";

type LocalizedPrice<Currency extends CurrencyCode, Amount extends number> = `${Currency} ${Amount}`;

type USPrice = LocalizedPrice<"USD", 99.99>; // Type is "USD 99.99"

//Example of validation
type IsValidCurrencyCode<T extends string> = T extends CurrencyCode ? T : never;

type ValidCode = IsValidCurrencyCode<"EUR"> // Type is "EUR"
type InvalidCode = IsValidCurrencyCode<"XYZ"> // Type is never

            

              
                Copy
              
            
          

यह उदाहरण दिखाता है कि स्थानीयकृत कीमतों का एक टाइप-सेफ प्रतिनिधित्व कैसे बनाया जाए और मुद्रा कोड को कैसे मान्य किया जाए, जो डेटा की शुद्धता के बारे में कंपाइल-टाइम गारंटी प्रदान करता है।

पार्सर कॉम्बिनेटर्स का उपयोग करने के लाभ

• टाइप सुरक्षा: यह सुनिश्चित करता है कि स्ट्रिंग हेरफेर टाइप-सेफ हैं, जिससे रनटाइम त्रुटियों का खतरा कम हो जाता है।
• पुन: प्रयोज्यता: पार्सर कॉम्बिनेटर्स पुन: प्रयोज्य बिल्डिंग ब्लॉक्स हैं जिन्हें अधिक जटिल पार्सिंग कार्यों को संभालने के लिए जोड़ा जा सकता है।
• पठनीयता: पार्सर कॉम्बिनेटर्स की मॉड्यूलर प्रकृति कोड पठनीयता और रखरखाव में सुधार कर सकती है।
• कंपाइल-टाइम सत्यापन: सत्यापन कंपाइल-टाइम पर होता है, जिससे विकास प्रक्रिया में त्रुटियों को जल्दी पकड़ा जा सकता है।

सीमाएं

• जटिलता: जटिल पार्सर बनाना चुनौतीपूर्ण हो सकता है और इसके लिए टाइपस्क्रिप्ट के टाइप सिस्टम की गहरी समझ की आवश्यकता होती है।
• प्रदर्शन: टाइप-स्तर की गणना धीमी हो सकती है, खासकर बहुत जटिल प्रकारों के लिए।
• त्रुटि संदेश: जटिल प्रकार की त्रुटियों के लिए टाइपस्क्रिप्ट के त्रुटि संदेशों की व्याख्या करना कभी-कभी मुश्किल हो सकता है।
• अभिव्यक्ति: शक्तिशाली होने के बावजूद, टाइपस्क्रिप्ट टाइप सिस्टम में कुछ प्रकार के स्ट्रिंग हेरफेर (जैसे, पूर्ण रेगुलर एक्सप्रेशन समर्थन) को व्यक्त करने की क्षमता में सीमाएं हैं। अधिक जटिल पार्सिंग परिदृश्य रनटाइम पार्सिंग लाइब्रेरी के लिए बेहतर अनुकूल हो सकते हैं।

निष्कर्ष

टाइपस्क्रिप्ट के टेम्पलेट लिटरल प्रकार, कंडीशनल प्रकारों और टाइप इनफेरेंस के साथ मिलकर, कंपाइल-टाइम पर स्ट्रिंग प्रकारों में हेरफेर और विश्लेषण के लिए एक शक्तिशाली टूलकिट प्रदान करते हैं। पार्सर कॉम्बिनेटर्स जटिल टाइप-स्तर के पार्सर बनाने के लिए एक संरचित दृष्टिकोण प्रदान करते हैं, जो आपके टाइपस्क्रिप्ट प्रोजेक्ट्स में मजबूत टाइप सत्यापन और परिवर्तन को सक्षम करते हैं। यद्यपि सीमाएं हैं, टाइप सुरक्षा, पुन: प्रयोज्यता, और कंपाइल-टाइम सत्यापन के लाभ इस तकनीक को आपके टाइपस्क्रिप्ट शस्त्रागार में एक मूल्यवान जोड़ बनाते हैं।

इन तकनीकों में महारत हासिल करके, आप अधिक मजबूत, टाइप-सेफ और रखरखाव योग्य एप्लिकेशन बना सकते हैं जो टाइपस्क्रिप्ट के टाइप सिस्टम की पूरी शक्ति का लाभ उठाते हैं। अपनी विशिष्ट आवश्यकताओं के लिए टाइप-स्तर पार्सिंग बनाम रनटाइम पार्सिंग का उपयोग करने का निर्णय लेते समय जटिलता और प्रदर्शन के बीच के ट्रेड-ऑफ पर विचार करना याद रखें।

यह दृष्टिकोण डेवलपर्स को त्रुटि का पता लगाने को कंपाइल-टाइम में स्थानांतरित करने की अनुमति देता है, जिसके परिणामस्वरूप अधिक अनुमानित और विश्वसनीय एप्लिकेशन बनते हैं। इस बात पर विचार करें कि इसका अंतर्राष्ट्रीयकृत प्रणालियों के लिए क्या निहितार्थ है - देश कोड, भाषा कोड और दिनांक प्रारूपों को कंपाइल-टाइम पर मान्य करने से स्थानीयकरण बग में काफी कमी आ सकती है और वैश्विक दर्शकों के लिए उपयोगकर्ता अनुभव में सुधार हो सकता है।

आगे की खोज

• अधिक उन्नत पार्सर कॉम्बिनेटर तकनीकों का अन्वेषण करें, जैसे कि बैकट्रैकिंग और त्रुटि सुधार।
• उन पुस्तकालयों की जांच करें जो टाइपस्क्रिप्ट प्रकारों के लिए पूर्व-निर्मित पार्सर कॉम्बिनेटर प्रदान करते हैं।
• कोड जनरेशन और अन्य उन्नत उपयोग के मामलों के लिए टेम्पलेट लिटरल प्रकारों का उपयोग करने के साथ प्रयोग करें।
• उन ओपन-सोर्स प्रोजेक्ट्स में योगदान करें जो इन तकनीकों का उपयोग करते हैं।

लगातार सीखने और प्रयोग करने से, आप टाइपस्क्रिप्ट के टाइप सिस्टम की पूरी क्षमता को अनलॉक कर सकते हैं और अधिक परिष्कृत और विश्वसनीय एप्लिकेशन बना सकते हैं।