TypeScript Template Literal Validatsiya Dvigunilari: Ish vaqtidagi Qator Tekshiruvi

TypeScript'ning template literal tiplari kuchli kompyuter vaqtidagi qator manipulyatsiyasi va tip xavfsizligini taqdim etadi. Biroq, bu tekshiruvlar faqat kompyuter vaqti bilan cheklangan. Ushbu blog postida TypeScript template literal tiplari uchun ish vaqtidagi validatsiya dvigunini qanday qurish mumkinligi ko'rib chiqiladi, bu esa mustahkam qator tekshiruvini ta'minlaydi va dastur ish vaqtida potensial xatoliklarni oldini oladi.

TypeScript Template Literal Tiplariga Kirish

Template literal tiplari, literal qiymatlar, birikmalar va tipni aniqlash asosida aniq qator shakllarini belgilash imkonini beradi. Bu ayniqsa, tuzilmali ma'lumotlar yoki domen-spetsifik tillar bilan ishlashda aniq tip tekshiruvi va avtomatik to'ldirishni ta'minlaydi.

Misol uchun, valyuta kodlarini ifodalovchi tipni ko'rib chiqing:

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

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

const validCurrency: FormattedCurrencyString = "USD-100"; // OK
const invalidCurrency: FormattedCurrencyString = "CAD-50"; // Kompyuter vaqtida tip xatosi

            

              
                Copy
              
            
          

Bu misol, TypeScript FormattedCurrencyString tipini kompyuter vaqtida qanday qat'iy bajariyotganini ko'rsatadi. Biroq, agar valyuta kodi tashqi manbadan (masalan, foydalanuvchi kiritishi, API javobi) kelsa, siz tip xavfsizligini ta'minlash uchun ish vaqtidagi validatsiyaga muhtoj bo'lasiz.

Ish Vaqtida Validatsiyaga Ehtiyoj

TypeScript mukammal kompyuter vaqtidagi tip tekshiruvini ta'minlasa-da, u ish vaqtida tashqi manbalardan olingan ma'lumotlarning haqiqiyligini kafolatlay olmaydi. Faqat kompyuter vaqtidagi tiplarga tayanish kutilmagan xatolarga va zaifliklarga olib kelishi mumkin.

Quyidagi vaziyatni ko'rib chiqing:

            
function processCurrency(currencyString: FormattedCurrencyString) {
  // ... qator to'g'ri formatlangan deb hisoblaydigan ba'zi mantiq
}

const userInput = "CAD-50"; // Bu foydalanuvchi kiritishidan kelgan deb taxmin qilinadi

// Bu kompyuterga o'tadi, lekin agar `processCurrency` ichidagi mantiq
// formatga tayansa, ish vaqtida xatolikka olib keladi.
processCurrency(userInput as FormattedCurrencyString);

            

              
                Copy
              
            
          

Bu holda, biz userInput ni FormattedCurrencyString ga aylantiryapmiz, TypeScript'ning kompyuter vaqtidagi tekshiruvlaridan o'tib ketamiz. Agar processCurrency qatorning to'g'ri formatlanganligiga tayansa, u ish vaqtida xatolikka duch keladi.

Ish vaqtida validatsiya, ish vaqtida olingan ma'lumotlar kutilgan TypeScript tiplariga mos kelishini tekshirish orqali ushbu bo'shliqni to'ldiradi.

Template Literal Validatsiya Dvigunini Qurish

Biz regular expressions va TypeScript'ning tip tizimini ishlatib, ish vaqtida validatsiya dvigunini qurishimiz mumkin. Dvigun, template literal tipini va bir qatorni kiritish sifatida oladi va qator tipga mos kelishini qaytaradi.

1-qadam: Ish Vaqtida Validatsiya Uchun Tipni Aniqlash

Avvalo, biz template literal tipining ish vaqtidagi ekvivalentini ifodalay oladigan umumiy (generic) tipga muhtojmiz. Ushbu tip turli xil template literal turlarini, shu jumladan literal, birikmalar (unions) va tip parametrlarni o'z ichiga oladi.

            
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
              
            
          

Ushbu rekursiv tip ta'rifi, template literallarni uning tarkibiy qismlariga bo'lib, har bir qismni regular expression patterniga aylantiradi.

2-qadam: Validatsiya Funksiyasini Joriy Etish

Keyingi qadamda, template literal tipini va validatsiya qilinadigan qatorni kiritish sifatida oladigan validatsiya funksiyasini joriy etamiz. Ushbu funksiya, TemplateLiteralToRegex tomonidan yaratilgan regular expression'dan foydalanib qatorni sinaydi.

            
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 {
  // Literal qatorlar uchun asosiy konvertatsiya - murakkabroq vaziyatlar uchun kengaytiring
  return templateType.replace(/[.*+?^${}()[|[\]]/g, '\$&'); // Maxsus regex belgilarni qochish
}

            

              
                Copy
              
            
          

Ushbu funksiya maxsus regular expression belgilarini qochib, template literal tipidan regular expression yaratadi, keyin esa qatorni ushbu regular expressionga qarshi sinaydi.

3-qadam: Validatsiya Dvigunidan Foydalanish

Endi siz isValid funksiyasidan foydalanib, qatorlarni o'z template literal tiplaringizga qarshi ish vaqtida validatsiya qilishingiz mumkin.

            
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
              
            
          

Ushbu misol, foydalanuvchi kiritishini FormattedCurrencyString tipiga qarshi validatsiya qilish uchun isValid funksiyasidan qanday foydalanishni ko'rsatadi. Chiqarish, ko'rsatilgan template literal asosida kiritish qatorlari haqiqiy yoki yo'qligini ko'rsatadi.

Murakkab Validatsiya Vaziyatlari

Asosiy validatsiya dviguni birikmalar (unions), shartli tiplar va rekursiv tiplar kabi murakkabroq vaziyatlarni o'z ichiga olish uchun kengaytirilishi mumkin.

Birikmalarni (Unions) Boshqarish

Birikmalarni boshqarish uchun, siz TemplateLiteralToRegex tipini har qanday birikma a'zolarini mos keladigan regular expression'ni yaratish uchun o'zgartirishingiz mumkin.

            
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
              
            
          

Shartli Tiplarni Boshqarish

Shartli tiplar, shartni ish vaqtida baholash va natijaga asoslanib turli regular expression'larni yaratish orqali boshqarilishi mumkin.

            
type IsString = T extends string ? true : false;

// Ushbu misol yanada murakkabroq mantiqni talab qiladi va sodda regex yordamida to'liq
// joriy etilmaydi. Ish vaqtida tip qo'riqchilari ushbu maxsus vaziyatda
// yanada mustahkam yechimni taqdim etadi.
// Quyidagi kod ko'rsatuvchi hisoblanadi va murakkab shartli tiplarni boshqarish uchun
// moslashtirilishi kerak.

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
              
            
          

Rekursiv Tiplarni Boshqarish

Rekursiv tiplar, regular expression pattern'ini yaratadigan rekursiv funksiyani aniqlash orqali boshqarilishi mumkin. Biroq, cheksiz rekursiya va stack overflow xatolaridan saqlanish uchun ehtiyot bo'ling. Chuqur rekursiya uchun, tegishli chegaralari bo'lgan iterativ yondashuvlar muhimdir.

Regular Expressionsdan Tashqari Alternativlar

Regular expressions qator validatsiyasi uchun kuchli vosita bo'lsa-da, ular murakkab va saqlash qiyin bo'lishi mumkin. Ish vaqtida validatsiya qilishning boshqa usullari quyidagilarni o'z ichiga oladi:

• Maxsus Validatsiya Funksiyalari: Dasturingiz talablariga asoslangan holda maxsus tiplarni validatsiya qilish uchun maxsus funksiyalarni yozing.
• Tip Qo'riqchilari (Type Guards): Ish vaqtida o'zgaruvchining tipini toraytirish uchun tip qo'riqchilaridan foydalaning.
• Validatsiya Kutubxonalari: Validatsiya jarayonini soddalashtirish uchun Zod yoki Yup kabi mavjud validatsiya kutubxonalaridan foydalaning.

Masalan, Zod, validatsiya ish vaqtiga tarjima qilinadigan sxema asosida deklaratsiyani taqdim etadi:

            
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); // Agar parse xato bo'lsa, bu ishlamaydi.
  } catch (error) {
    console.error("Invalid Currency:", error);
  }


            

              
                Copy
              
            
          

Ish Vaqtida Validatsiya Uchun Eng Yaxshi Amaliyotlar

Ish vaqtida validatsiyani amalga oshirishda quyidagi eng yaxshi amaliyotlarni yodda tuting:

• Chegarada Validatsiya Qiling: Ma'lumotlar tizimingizga kirishi bilan (masalan, foydalanuvchi kiritishi, API javoblari) validatsiya qiling.
• Aniq Xato Xabarlarini Ta'minlang: Foydalanuvchilarga ularning kiritishi nima uchun haqiqiy emasligini tushunishga yordam beradigan ma'lumotli xatolarni yarating.
• Doimiy Validatsiya Strategiyasidan Foydalaning: Ma'lumotlar yaxlitligini ta'minlash uchun dasturingiz bo'ylab doimiy validatsiya strategiyasini qabul qiling.
• Validatsiya Mantiqini Sinab Ko'ring: U haqiqiy va haqiqiy emas ma'lumotlarni to'g'ri aniqlashini ta'minlash uchun validatsiya mantiqini to'liq sinab ko'ring.
• Ishlash va Xavfsizlikni Muvozanatlashtiring: Xavfsizlik zaifliklarini samarali ravishda oldini olish bilan birga, ish faoliyati uchun validatsiya mantiqini optimallashtiring. Xizmatdan voz kechishga olib keladigan haddan tashqari murakkab regexlardan qoching.

Xalqaro Ta'minlash (Internationalization) Masalalari

Global kontekstda qator validatsiyasi bilan ishlayotganda, siz xalqaro ta'minlash (i18n) va lokalizatsiya (l10n) ni hisobga olishingiz kerak. Turli xil lokalarda sanalar, raqamlar va valyuta qiymatlari kabi qatorlarni formatlash uchun turli qoidalar bo'lishi mumkin.

Masalan, Yevro (€) uchun valyuta belgisi lokalga qarab miqdorning oldida yoki keyin kelishi mumkin. Xuddi shunday, o'nli ajratuvchi nuqta (.) yoki vergul (,) bo'lishi mumkin.

Ushbu o'zgarishlarni boshqarish uchun siz Intl kabi xalqaro ta'minlash kutubxonalaridan foydalanishingiz mumkin, u lokalga sezgir ma'lumotlarni formatlash va parslash uchun API'larni taqdim etadi. Misol uchun, siz turli valyuta formatlarini boshqarish uchun avvalgi misolni moslashtirishingiz mumkin:

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

    // Ushbu misol faqat juda sodda. Formatter yordamida valyutani parslashga harakat qiling.
    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
              
            
          

Ushbu kod parchasi asosiy misolni taqdim etadi. To'g'ri xalqaro ta'minlash yanada puxta boshqaruvni talab qiladi, potentsial ravishda turli xil lokalarda valyuta formatlash va validatsiyasi uchun maxsus mo'ljallangan tashqi kutubxonalar yoki API'lardan foydalaniladi.

Xulosa

Ish vaqtida validatsiya mustahkam va ishonchli TypeScript dasturlarini yaratishning muhim qismidir. TypeScript'ning template literal tiplarini regular expressions yoki muqobil validatsiya usullari bilan birlashtirish orqali siz ish vaqtida qatorlarining haqiqiyligini tekshirish uchun kuchli dvigunni yaratishingiz mumkin.

Ushbu yondashuv tip xavfsizligini oshiradi, kutilmagan xatolarni oldini oladi va kodingizning umumiy sifatini yaxshilaydi. Yanada murakkab dasturlarni qurishda, sizning ma'lumotlaringiz kutilgan tiplar va formatlarga mos kelishini ta'minlash uchun ish vaqtida validatsiyani kiritishni ko'rib chiqing.

Qo'shimcha Tadqiqotlar

• Yanada murakkab validatsiya vaziyatlari uchun ilg'or regular expression usullarini o'rganing.
• Sxema asosida validatsiya qilish uchun Zod va Yup kabi validatsiya kutubxonalarini tekshiring.
• TypeScript tiplaridan avtomatik ravishda validatsiya funksiyalarini yaratish uchun kod yaratish usullaridan foydalanishni ko'rib chiqing.
• Lokalga sezgir ma'lumotlarni boshqarish uchun xalqaro ta'minlash kutubxonalari va API'larini o'rganing.