टाइपस्क्रिप्ट टेम्पलेट लिटरल वैलिडेशन इंजन: रनटाइम स्ट्रिंग सत्यापन

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

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

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

उदाहरण के लिए, मुद्रा कोड का प्रतिनिधित्व करने के लिए एक टाइप पर विचार करें:

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

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const validCurrency: FormattedCurrencyString = "USD-100"; // OK
const invalidCurrency: FormattedCurrencyString = "CAD-50"; // Type error at compile time

            

              
                Copy
              
            
          

यह उदाहरण दिखाता है कि टाइपस्क्रिप्ट कंपाइल-टाइम पर FormattedCurrencyString टाइप को कैसे लागू करता है। हालाँकि, यदि मुद्रा कोड किसी बाहरी स्रोत (जैसे, उपयोगकर्ता इनपुट, एपीआई प्रतिक्रिया) से आता है, तो टाइप सेफ्टी सुनिश्चित करने के लिए आपको रनटाइम वैलिडेशन की आवश्यकता होती है।

रनटाइम वैलिडेशन की आवश्यकता

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

निम्नलिखित परिदृश्य पर विचार करें:

            
function processCurrency(currencyString: FormattedCurrencyString) {
  // ... some logic that assumes the string is correctly formatted
}

const userInput = "CAD-50"; // Assume this comes from user input

// This will compile, but will cause a runtime error if the logic inside
// `processCurrency` relies on the format.
processCurrency(userInput as FormattedCurrencyString);

            

              
                Copy
              
            
          

इस मामले में, हम userInput को FormattedCurrencyString में कास्ट कर रहे हैं, जिससे टाइपस्क्रिप्ट की कंपाइल-टाइम जाँचों को बायपास किया जा रहा है। यदि processCurrency स्ट्रिंग के सही ढंग से स्वरूपित होने पर निर्भर करता है, तो उसे एक रनटाइम त्रुटि का सामना करना पड़ेगा।

रनटाइम वैलिडेशन यह सत्यापित करके इस अंतर को पाटता है कि रनटाइम पर प्राप्त डेटा अपेक्षित टाइपस्क्रिप्ट टाइप्स के अनुरूप है।

एक टेम्पलेट लिटरल वैलिडेशन इंजन का निर्माण

हम रेगुलर एक्सप्रेशंस और टाइपस्क्रिप्ट के टाइप सिस्टम का उपयोग करके एक रनटाइम वैलिडेशन इंजन बना सकते हैं। यह इंजन एक टेम्पलेट लिटरल टाइप और एक स्ट्रिंग को इनपुट के रूप में लेगा और यह बताएगा कि स्ट्रिंग उस टाइप से मेल खाती है या नहीं।

चरण 1: रनटाइम वैलिडेशन के लिए एक टाइप परिभाषित करना

सबसे पहले, हमें एक जेनेरिक टाइप की आवश्यकता है जो एक टेम्पलेट लिटरल टाइप के रनटाइम समकक्ष का प्रतिनिधित्व कर सके। इस टाइप को विभिन्न प्रकार के टेम्पलेट लिटरल्स को संभालने में सक्षम होना चाहिए, जिसमें लिटरल्स, यूनियंस और टाइप पैरामीटर शामिल हैं।

            
type TemplateLiteralToRegex = 
  T extends `${infer Start}${infer Middle}${infer End}`
    ? Start extends string
      ? Middle extends string
        ? End extends string
          ? TemplateLiteralToRegexStart & TemplateLiteralToRegexMiddle & TemplateLiteralToRegex
          : never
        : never
      : never
    : TemplateLiteralToRegexStart;


type TemplateLiteralToRegexStart = T extends `${infer Literal}` ? Literal : string;

type TemplateLiteralToRegexMiddle = T extends `${infer Literal}` ? Literal : string;

            

              
                Copy
              
            
          

यह रिकर्सिव टाइप परिभाषा टेम्पलेट लिटरल को उसके घटक भागों में तोड़ देती है और प्रत्येक भाग को एक रेगुलर एक्सप्रेशन पैटर्न में परिवर्तित करती है।

चरण 2: वैलिडेशन फ़ंक्शन को लागू करना

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

            
function isValid(str: string, templateType: T): boolean {
  const regexPattern = `^${convertTemplateLiteralToRegex(templateType)}$`;
  const regex = new RegExp(regexPattern);
  return regex.test(str);
}

function convertTemplateLiteralToRegex(templateType: T): string {
  // Basic conversion for literal strings - extend this for more complex scenarios
  return templateType.replace(/[.*+?^${}()|\[\]]/g, '\\$&'); // Escape special regex characters
}

            

              
                Copy
              
            
          

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

चरण 3: वैलिडेशन इंजन का उपयोग करना

अब, आप रनटाइम पर अपने टेम्पलेट लिटरल टाइप्स के विरुद्ध स्ट्रिंग्स को मान्य करने के लिए isValid फ़ंक्शन का उपयोग कर सकते हैं।

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

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

const userInput1 = "USD-100";
const userInput2 = "CAD-50";

console.log(`'${userInput1}' is valid: ${isValid(userInput1, "USD-100" )}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, "USD-100")}`); // false

console.log(`'${userInput1}' is valid: ${isValid(userInput1, `USD-${100}`)}`); // true
console.log(`'${userInput2}' is valid: ${isValid(userInput2, `USD-${100}`)}`); // false


            

              
                Copy
              
            
          

यह उदाहरण दिखाता है कि FormattedCurrencyString टाइप के विरुद्ध उपयोगकर्ता इनपुट को मान्य करने के लिए isValid फ़ंक्शन का उपयोग कैसे करें। आउटपुट दिखाएगा कि निर्दिष्ट टेम्पलेट लिटरल के आधार पर इनपुट स्ट्रिंग्स को वैध माना जाता है या नहीं।

उन्नत वैलिडेशन परिदृश्य

मूल वैलिडेशन इंजन को यूनियनों, कंडीशनल टाइप्स और रिकर्सिव टाइप्स जैसे अधिक जटिल परिदृश्यों को संभालने के लिए विस्तारित किया जा सकता है।

यूनियनों को संभालना

यूनियनों को संभालने के लिए, आप TemplateLiteralToRegex टाइप को एक रेगुलर एक्सप्रेशन उत्पन्न करने के लिए संशोधित कर सकते हैं जो किसी भी यूनियन सदस्य से मेल खाता हो।

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

type FormattedCurrencyString = `${CurrencyCode}-${number}`;

function isValidCurrencyCode(str: string, templateType: T): boolean {
    const currencyCodes: CurrencyCode[] = ["USD", "EUR", "GBP"];
    return currencyCodes.includes(str as CurrencyCode);
}


function isValidUnionFormattedCurrencyString(str: string): boolean {
    const parts = str.split('-');
    if(parts.length !== 2) return false;
    const [currencyCode, amount] = parts;

    if (!isValidCurrencyCode(currencyCode, currencyCode)) return false;

    if (isNaN(Number(amount))) return false;

    return true;
}

console.log(`'USD-100' is valid formatted string: ${isValidUnionFormattedCurrencyString('USD-100')}`);
console.log(`'CAD-50' is valid formatted string: ${isValidUnionFormattedCurrencyString('CAD-50')}`);


            

              
                Copy
              
            
          

कंडीशनल टाइप्स को संभालना

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

            
type IsString = T extends string ? true : false;

// This example requires more advanced logic and isn't fully implementable using simple regex.
// Runtime type guards offer a more robust solution in this specific scenario.
// The below code is illustrative and would need adaptation to handle complex conditional types.

function isString(value: any): value is string {
    return typeof value === 'string';
}

function isValidConditionalType(value: any): boolean {
    return isString(value);
}

console.log(`'hello' is a string: ${isValidConditionalType('hello')}`);
console.log(`123 is a string: ${isValidConditionalType(123)}`);

            

              
                Copy
              
            
          

रिकर्सिव टाइप्स को संभालना

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

रेगुलर एक्सप्रेशंस के विकल्प

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

• कस्टम वैलिडेशन फंक्शंस: अपनी एप्लिकेशन की आवश्यकताओं के आधार पर विशिष्ट टाइप्स को मान्य करने के लिए कस्टम फंक्शंस लिखें।
• टाइप गार्ड्स: रनटाइम पर किसी वेरिएबल के टाइप को सीमित करने के लिए टाइप गार्ड्स का उपयोग करें।
• वैलिडेशन लाइब्रेरीज: वैलिडेशन प्रक्रिया को सरल बनाने के लिए Zod या Yup जैसी मौजूदा वैलिडेशन लाइब्रेरीज का लाभ उठाएं।

उदाहरण के लिए, Zod एक स्कीमा-आधारित घोषणा प्रदान करता है जो एक वैलिडेशन रनटाइम में बदल जाती है:

            
import { z } from 'zod';

const CurrencyCodeSchema = z.enum(['USD', 'EUR', 'GBP']);
const FormattedCurrencyStringSchema = z.string().regex(new RegExp(`^${CurrencyCodeSchema.enum.USD}|${CurrencyCodeSchema.enum.EUR}|${CurrencyCodeSchema.enum.GBP}-[0-9]+$`));

try {
  const validCurrency = FormattedCurrencyStringSchema.parse("USD-100");
  console.log("Valid Currency:", validCurrency);
} catch (error) {
  console.error("Invalid Currency:", error);
}

try {
    const invalidCurrency = FormattedCurrencyStringSchema.parse("CAD-50");
    console.log("Valid Currency:", invalidCurrency); //This won't execute if parse fails.
  } catch (error) {
    console.error("Invalid Currency:", error);
  }


            

              
                Copy
              
            
          

रनटाइम वैलिडेशन के लिए सर्वोत्तम प्रथाएं

रनटाइम वैलिडेशन लागू करते समय, निम्नलिखित सर्वोत्तम प्रथाओं को ध्यान में रखें:

• सीमा पर मान्य करें: जैसे ही डेटा आपके सिस्टम में प्रवेश करता है (जैसे, उपयोगकर्ता इनपुट, एपीआई प्रतिक्रियाएं), उसे मान्य करें।
• स्पष्ट त्रुटि संदेश प्रदान करें: उपयोगकर्ताओं को यह समझने में मदद करने के लिए सूचनात्मक त्रुटि संदेश उत्पन्न करें कि उनका इनपुट अमान्य क्यों है।
• एक सुसंगत वैलिडेशन रणनीति का उपयोग करें: डेटा अखंडता सुनिश्चित करने के लिए अपने एप्लिकेशन में एक सुसंगत वैलिडेशन रणनीति अपनाएं।
• अपने वैलिडेशन लॉजिक का परीक्षण करें: यह सुनिश्चित करने के लिए अपने वैलिडेशन लॉजिक का अच्छी तरह से परीक्षण करें कि यह वैध और अमान्य डेटा की सही पहचान करता है।
• प्रदर्शन और सुरक्षा को संतुलित करें: सुरक्षा कमजोरियों को प्रभावी ढंग से रोकते हुए प्रदर्शन के लिए अपने वैलिडेशन लॉजिक को अनुकूलित करें। अत्यधिक जटिल रेगेक्स से बचें जो सेवा से इनकार (denial of service) का कारण बन सकता है।

अंतर्राष्ट्रीयकरण संबंधी विचार

जब वैश्विक संदर्भ में स्ट्रिंग वैलिडेशन से निपटते हैं, तो आपको अंतर्राष्ट्रीयकरण (i18n) और स्थानीयकरण (l10n) पर विचार करने की आवश्यकता है। विभिन्न लोकेल में स्ट्रिंग्स, जैसे तिथियों, संख्याओं और मुद्रा मानों को स्वरूपित करने के लिए अलग-अलग नियम हो सकते हैं।

उदाहरण के लिए, यूरो (€) के लिए मुद्रा प्रतीक लोकेल के आधार पर राशि से पहले या बाद में दिखाई दे सकता है। इसी तरह, दशमलव विभाजक एक बिंदु (.) या एक अल्पविराम (,) हो सकता है।

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

            
function isValidCurrencyString(currencyString: string, locale: string): boolean {
  try {
    const formatter = new Intl.NumberFormat(locale, { style: 'currency', currency: currencyString.substring(0,3) }); //Very basic example

    //Attempt to parse the currency using formatter. This example is intentionally very simple.
    return true;
  } catch (error) {
    return false;
  }
}

console.log(`USD-100 is valid for en-US: ${isValidCurrencyString('USD-100', 'en-US')}`);
console.log(`EUR-100 is valid for fr-FR: ${isValidCurrencyString('EUR-100', 'fr-FR')}`);

            

              
                Copy
              
            
          

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

निष्कर्ष

रनटाइम वैलिडेशन मजबूत और विश्वसनीय टाइपस्क्रिप्ट एप्लिकेशन बनाने का एक अनिवार्य हिस्सा है। टाइपस्क्रिप्ट के टेम्पलेट लिटरल टाइप्स को रेगुलर एक्सप्रेशंस या वैकल्पिक वैलिडेशन विधियों के साथ जोड़कर, आप रनटाइम पर स्ट्रिंग्स की वैधता को सत्यापित करने के लिए एक शक्तिशाली इंजन बना सकते हैं।

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

आगे की खोज

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