Template Literal Types: String Pattern Matching and Validation in TypeScript

TypeScript'ning tur tizimi doimiy ravishda rivojlanib, dasturchilarga murakkab mantiqni ifodalash va tur xavfsizligini ta'minlash uchun yanada kuchli vositalarni taklif etadi. So'nggi versiyalarda taqdim etilgan eng qiziqarli va ko'p qirrali xususiyatlardan biri shablon literal turlaridir. Ushbu turlar sizga satrlarni tur darajasida boshqarish imkonini beradi, bu esa ilg'or satr namunasini moslashtirish va tasdiqlash imkonini beradi. Bu yanada mustahkam va saqlashga yaroqli ilovalarni yaratish uchun butunlay yangi imkoniyatlar dunyosini ochadi.

Template Literal Turlari nima?

Shablon literal turlari - bu JavaScript-dagi shablon literallari qanday ishlashiga o'xshab, satr literal turlari va birlashma turlarini birlashtirish orqali qurilgan tur shaklidir. Biroq, ish vaqtida satrlarni yaratish o'rniga, ular mavjudlar asosida yangi turlarni yaratadilar.

Mana oddiy misol:

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

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

            

              
                Copy
              
            
          

Ushbu misolda, `Greeting` - bu satr turi `T` ni kirish sifatida qabul qiladigan va "Hello, ", `T` va "!" ning birikmasi bo'lgan yangi tur qaytaradigan shablon literal turi.

Satr Namunasini Asosiy Moslashtirish

Shablon literal turlari satr namunasini asosiy moslashtirishni amalga oshirish uchun ishlatilishi mumkin. Bu sizga faqat ma'lum bir namunaga mos keladigan bo'lsa, amal qiladigan turlarni yaratishga imkon beradi.

Masalan, siz faqat "prefix-" bilan boshlanadigan satrlarni qabul qiladigan tur yaratishingiz mumkin:

            type PrefixedString<T extends string> = T extends `prefix-${string}` ? T : never;

type ValidPrefixedString = PrefixedString<"prefix-valid">; // type ValidPrefixedString = "prefix-valid"
type InvalidPrefixedString = PrefixedString<"invalid">; // type InvalidPrefixedString = never

            

              
                Copy
              
            
          

Ushbu misolda, `PrefixedString` kirish satri `T` "prefix-" bilan boshlanishini tekshirish uchun shartli turdan foydalanadi. Agar shunday bo'lsa, tur o'zi `T`; aks holda, u `never`. `never` - TypeScript-dagi maxsus tur bo'lib, u hech qachon sodir bo'lmaydigan qiymatlar turini ifodalaydi va samarasiz satrni chiqarib tashlaydi.

Satrning Qismlarini Ajratib Olish

Shablon literal turlari, shuningdek, satrning qismlarini ajratib olish uchun ham ishlatilishi mumkin. Bu, ayniqsa, satrlardan ma'lumotlarni tahlil qilish va uni turli xil turlarga aylantirish kerak bo'lganda foydalidir.

Aytaylik, sizda "x:10,y:20" formatida koordinatani ifodalovchi satr bor. X va y qiymatlarini ajratib olish uchun shablon literal turlaridan foydalanishingiz mumkin:

            type CoordinateString = `x:${number},y:${number}`;

type ExtractX<T extends CoordinateString> = T extends `x:${infer X},y:${number}` ? X : never;
type ExtractY<T extends CoordinateString> = T extends `x:${number},y:${infer Y}` ? Y : never;

type XValue = ExtractX<"x:10,y:20">; // type XValue = 10
type YValue = ExtractY<"x:10,y:20">; // type YValue = 20

            

              
                Copy
              
            
          

Ushbu misolda, `ExtractX` va `ExtractY` `infer` kalit so'zidan foydalanib, `number` turiga mos keladigan satr qismlarini oladi. `infer` sizga namunaviy moslikdan tur ajratib olish imkonini beradi. Keyin olingan turlar shartli turning qaytarilish turi sifatida ishlatiladi.

Satrlarni Ilg'or Tasdiqlash

Shablon literal turlarini satrlarni ilg'or tasdiqlashni amalga oshirish uchun birlashma turlari va shartli turlar kabi boshqa TypeScript xususiyatlari bilan birlashtirish mumkin. Bu sizga satrlarning tuzilishi va mazmuniga murakkab qoidalarni joriy qiladigan turlarni yaratishga imkon beradi.

Masalan, siz ISO 8601 sana satrlarini tasdiqlaydigan tur yaratishingiz mumkin:

            type Year = `${number}${number}${number}${number}`;
type Month = `0${number}` | `10` | `11` | `12`;
type Day = `${0}${number}` | `${1 | 2}${number}` | `30` | `31`;

type ISODate = `${Year}-${Month}-${Day}`;

type ValidDate = ISODate extends "2023-10-27" ? true : false; // true
type InvalidDate = ISODate extends "2023-13-27" ? true : false; // false

function processDate(date: ISODate) {
  // Function logic here.  TypeScript enforces the ISODate format.
  return `Processing date: ${date}`;
}

console.log(processDate("2024-01-15")); // Works
//console.log(processDate("2024-1-15")); // TypeScript error: Argument of type '"2024-1-15"' is not assignable to parameter of type '`${number}${number}${number}${number}-${0}${number}-${0}${number}` | `${number}${number}${number}${number}-${0}${number}-${1}${number}` | ... 14 more ... | `${number}${number}${number}${number}-12-31`'.

            

              
                Copy
              
            
          

Bu erda `Year`, `Month` va `Day` sananing har bir qismi uchun amal qiladigan formatlarni ifodalash uchun shablon literal turlari yordamida aniqlanadi. Keyin `ISODate` ushbu turlarni birlashtirib, ISO 8601 sana satrini ifodalovchi tur yaratadi. Misol, shuningdek, ushbu turdan ma'lumotlarni formatlashni funktsiyada amalga oshirish, noto'g'ri sana formatlari o'tishining oldini olish uchun qanday foydalanish mumkinligini ko'rsatadi. Bu kodning ishonchliligini oshiradi va noto'g'ri kiritish natijasida yuzaga keladigan ish vaqti xatolarini oldini oladi.

Real Hayotda Foydalanish Holatlari

Shablon literal turlari real hayotda turli xil stsenariylarda ishlatilishi mumkin. Mana bir nechta misollar:

• Formani Tasdiqlash: Formadagi ma'lumotlarning formatini, masalan, elektron pochta manzillari, telefon raqamlari va pochta indekslarini tasdiqlash uchun shablon literal turlaridan foydalanishingiz mumkin.
• API So'rovini Tasdiqlash: API so'rov yuklamalarining tuzilishini tasdiqlash uchun shablon literal turlaridan foydalanishingiz mumkin, bu ularning kutilgan formatga mos kelishini ta'minlaydi. Misol uchun, valyuta kodini tasdiqlash (masalan, "USD", "EUR", "GBP").
• Konfiguratsiya Faylini Tahlil Qilish: Konfiguratsiya fayllarini tahlil qilish va ma'lum bir naqshlar asosida qiymatlarni ajratib olish uchun shablon literal turlaridan foydalanishingiz mumkin. Konfiguratsiya ob'ektidagi fayl yo'llarini tasdiqlashni ko'rib chiqing.
• Satrga Asoslangan Enums: Shablon literal turlari yordamida tasdiqlash bilan satrga asoslangan enumlarni yaratishingiz mumkin.

Misol: Valyuta Kodlarini Tasdiqlash

Valyuta kodlarini tasdiqlashning batafsil misolini ko'rib chiqaylik. Biz faqat haqiqiy ISO 4217 valyuta kodlaridan ilovamizda foydalanishni ta'minlamoqchimiz. Ushbu kodlar odatda uchta katta harfdan iborat.

            type CurrencyCode = `${Uppercase<string>}${Uppercase<string>}${Uppercase<string>}`;

function formatCurrency(amount: number, currency: CurrencyCode) {
  // Function logic to format currency based on the provided code.
  return `$${amount} ${currency}`;
}

console.log(formatCurrency(100, "USD")); // Works
//console.log(formatCurrency(100, "usd")); // TypeScript error: Argument of type '"usd"' is not assignable to parameter of type '`${Uppercase}${Uppercase}${Uppercase}`'.

//More precise example:
type ValidCurrencyCode = "USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"; // Extend as needed

type StronglyTypedCurrencyCode = ValidCurrencyCode;

function formatCurrencyStronglyTyped(amount: number, currency: StronglyTypedCurrencyCode) {
    return `$${amount} ${currency}`;
}

console.log(formatCurrencyStronglyTyped(100, "EUR")); // Works
//console.log(formatCurrencyStronglyTyped(100, "CNY")); // TypeScript error: Argument of type '"CNY"' is not assignable to parameter of type '"USD" | "EUR" | "GBP" | "JPY" | "CAD" | "AUD"'.

            

              
                Copy
              
            
          

Ushbu misol uchta katta harfdan iborat satrlarni qabul qiladigan `CurrencyCode` turini qanday yaratishni ko'rsatadi. Ikkinchi, kuchliroq tipdagi misol buni hatto maqbul valyutalarning oldindan belgilangan ro'yxatiga qanday cheklash mumkinligini ko'rsatadi.

Misol: API Endpoint Yo'llarini Tasdiqlash

Yana bir foydalanish holati - API endpoint yo'llarini tasdiqlash. So'rovlar to'g'ri yo'llarga yuborilishini ta'minlab, amal qiladigan API endpoint tuzilishini ifodalovchi tur belgilashingiz mumkin. Bu, ayniqsa, bir nechta xizmatlar turli API'larni ochishi mumkin bo'lgan mikroservislar arxitekturasida foydalidir.

            type APIServiceName = "users" | "products" | "orders";
type APIEndpointPath = `/${APIServiceName}/${string}`;

function callAPI(path: APIEndpointPath) {
  // API call logic
  console.log(`Calling API: ${path}`);
}

callAPI("/users/123"); // Valid
callAPI("/products/details"); // Valid
//callAPI("/invalid/path"); // TypeScript error

// Even more specific:
type APIAction = "create" | "read" | "update" | "delete";
type APIEndpointPathSpecific = `/${APIServiceName}/${APIAction}`;

function callAPISpecific(path: APIEndpointPathSpecific) {
  // API call logic
  console.log(`Calling specific API: ${path}`);
}

callAPISpecific("/users/create"); // Valid
//callAPISpecific("/users/list"); // TypeScript error

            

              
                Copy
              
            
          

Bu API endpointlarining tuzilishini aniqroq belgilash, xatolarni oldini olish va ilovangiz bo'ylab izchillikni ta'minlash imkonini beradi. Bu asosiy misol; so'rov parametrlarini va URLning boshqa qismlarini tasdiqlash uchun yanada murakkab naqshlar yaratilishi mumkin.

Shablon Literal Turlaridan Foydalanishning Afzalliklari

Satr namunasini moslashtirish va tasdiqlash uchun shablon literal turlaridan foydalanish bir qator afzalliklarni taqdim etadi:

• Yaxshilangan Tur Xavfsizligi: Shablon literal turlari satrlarda qat'iy tur cheklovlarini joriy qilish imkonini beradi, bu esa ish vaqti xavfi xatolarini kamaytiradi.
• Kodning O'qilishini Oshirish: Shablon literal turlari satrlarning kutilgan formatini aniq ifodalash orqali kodingizni yanada o'qilishi mumkin qiladi.
• Saqlashga Yaroqlilikni Oshirish: Shablon literal turlari satrlarni tasdiqlash qoidalari uchun yagona manba taqdim etish orqali kodingizni yanada saqlashga yaroqli qiladi.
• Dasturchi Tajribasini Yaxshilash: Shablon literal turlari yaxshiroq avtomatik to'ldirish va xato xabarlarini taqdim etadi, bu esa dasturchining umumiy tajribasini yaxshilaydi.

Cheklovlar

Shablon literal turlari kuchli bo'lsa-da, ularning ba'zi cheklovlari ham bor:

• Murakkablik: Shablon literal turlari, ayniqsa murakkab naqshlar bilan ishlaganda, murakkab bo'lishi mumkin. Tur xavfsizligi afzalliklarini kodni saqlashga yaroqlilik bilan muvozanatlash juda muhimdir.
• Ishlash: Shablon literal turlari kompilyatsiya ishlashiga ta'sir qilishi mumkin, ayniqsa katta loyihalarda. Buning sababi shundaki, TypeScript yanada murakkab tur tekshiruvini amalga oshirishi kerak.
• Regular Ifodalarni Cheklangan Qo'llab-quvvatlash: Shablon literal turlari naqshni moslashtirishga imkon bersa-da, ular regular ifoda xususiyatlarining to'liq spektrini qo'llab-quvvatlamaydi. Yuqori darajada murakkab satrlarni tasdiqlash uchun ushbu tur tuzilmalari bilan bir qatorda to'g'ri kiritishni tozalash uchun ish vaqti regular ifodalari hali ham zarur bo'lishi mumkin.

Eng Yaxshi Amaliyotlar

Shablon literal turlaridan foydalanganda yodda tutish kerak bo'lgan ba'zi eng yaxshi amaliyotlar:

• Oddiy Bilan Boshlang: Oddiy naqshlar bilan boshlang va kerak bo'lganda asta-sekin murakkablikni oshiring.
• Tavsiflovchi Nomlardan Foydalaning: Kodning o'qilishini yaxshilash uchun shablon literal turlaringiz uchun tavsiflovchi nomlardan foydalaning.
• Turlaringizni Hujjatlashtiring: Maqsad va foydalanishni tushuntirish uchun shablon literal turlaringizni hujjatlashtiring.
• Yaxshilab Sinovdan O'tkazing: Ularning kutilganidek ishlashini ta'minlash uchun shablon literal turlaringizni yaxshilab sinovdan o'tkazing.
• Ishlashni Hisobga Oling: Shablon literal turlarining kompilyatsiya ishlashiga ta'sirini hisobga oling va kodingizni shunga mos ravishda optimallashtiring.

Xulosa

Shablon literal turlari - TypeScript'dagi kuchli xususiyat bo'lib, u sizga tur darajasida ilg'or satrlarni manipulyatsiya qilish, naqshni moslashtirish va tasdiqlashni amalga oshirish imkonini beradi. Shablon literal turlaridan foydalanib, siz yanada mustahkam, saqlashga yaroqli va tur xavfsiz ilovalarni yaratishingiz mumkin. Ularning ba'zi cheklovlari bo'lsa-da, shablon literal turlaridan foydalanishning afzalliklari ko'pincha kamchiliklardan ustun turadi va ularni har qanday TypeScript dasturchisining arsenalida qimmatli vositaga aylantiradi. TypeScript tili rivojlanishda davom etar ekan, ushbu ilg'or tur xususiyatlarini tushunish va ulardan foydalanish yuqori sifatli dasturiy ta'minotni yaratish uchun juda muhim bo'ladi. Murakkablikni o'qilishi bilan muvozanatlashni unutmang va har doim yaxshilab sinovdan o'tkazishga ustunlik bering.